kuzzle 2.56.0 → 2.57.0-beta.1

package/dist/lib/service/storage/8/elasticsearch.js

@@ -102,8 +102,6 @@ class ES8 {
         this._scope = scope;
         this._indexPrefix =
             scope === storeScopeEnum_1.storeScopeEnum.PRIVATE ? PRIVATE_PREFIX : PUBLIC_PREFIX;
-        this._client = null;
-        this._esWrapper = null;
         this._esVersion = null;
         this._translator = new queryTranslator_1.QueryTranslator();
         // Allowed root key of a search query
@@ -160,9 +158,11 @@ class ES8 {
         await this.waitForElasticsearch();
         this._esWrapper = new esWrapper_1.default(this._client);
         const { version } = await this._client.info();
-        if (version &&
-            !semver_1.default.satisfies(semver_1.default.coerce(version.number), ">=8.0.0")) {
-            throw kerror.get("services", "storage", "version_mismatch", version.number);
+        if (version) {
+            const coerced = semver_1.default.coerce(version.number);
+            if (coerced === null || !semver_1.default.satisfies(coerced, ">=8.0.0")) {
+                throw kerror.get("services", "storage", "version_mismatch", version.number);
+            }
         }
         this._esVersion = version;
     }
@@ -213,7 +213,7 @@ class ES8 {
         const stats = await this._client.indices.stats(esRequest);
         const indexes = {};
         let size = 0;
-        for (const [indice, indiceInfo] of Object.entries(stats.indices)) {
+        for (const [indice, indiceInfo] of Object.entries(stats.indices ?? {})) {
             const infos = indiceInfo;
             // Ignore non-Kuzzle indices
             if (!indice.startsWith(PRIVATE_PREFIX) &&
@@ -228,19 +228,17 @@ class ES8 {
                 collectionName === HIDDEN_COLLECTION) {
                 continue;
             }
-            if (!indexes[indexName]) {
-                indexes[indexName] = {
-                    collections: [],
-                    name: indexName,
-                    size: 0,
-                };
-            }
-            indexes[indexName].collections.push({
+            const indexStats = (indexes[indexName] ?? (indexes[indexName] = {
+                collections: [],
+                name: indexName,
+                size: 0,
+            }));
+            indexStats.collections.push({
                 documentCount: infos.total.docs.count,
                 name: collectionName,
                 size: infos.total.store.size_in_bytes,
             });
-            indexes[indexName].size += infos.total.store.size_in_bytes;
+            indexStats.size += infos.total.store.size_in_bytes;
             size += infos.total.store.size_in_bytes;
         }
         return {
@@ -267,7 +265,7 @@ class ES8 {
         const cacheKey = SCROLL_CACHE_PREFIX + global.kuzzle.hash(esRequest.scroll_id);
         this.logger.debug("Scroll: %o", esRequest);
         if (_scrollTTL) {
-            const scrollDuration = (0, ms_1.default)(_scrollTTL);
+            const scrollDuration = (0, ms_1.default)(_scrollTTL) ?? 0;
             if (scrollDuration > this.maxScrollDuration) {
                 throw kerror.get("services", "storage", "scroll_duration_too_great", _scrollTTL);
             }
@@ -311,16 +309,12 @@ class ES8 {
     async search({ index, collection, searchBody, targets, } = {}, { from, size, scroll, } = {}) {
         let esIndexes;
         if (targets && targets.length > 0) {
-            const indexes = new Set();
-            for (const target of targets) {
-                for (const targetCollection of target.collections) {
-                    const alias = this._getAlias(target.index, targetCollection);
-                    indexes.add(alias);
-                }
-            }
-            esIndexes = Array.from(indexes).join(",");
+            esIndexes = this._targetsToIndexes(targets);
         }
         else {
+            if (index === undefined) {
+                throw kerror.get("services", "storage", "missing_argument", "index");
+            }
             esIndexes = this._getAlias(index, collection);
         }
         const esRequest = {
@@ -332,7 +326,7 @@ class ES8 {
             track_total_hits: true,
         };
         if (scroll) {
-            const scrollDuration = (0, ms_1.default)(scroll);
+            const scrollDuration = (0, ms_1.default)(scroll) ?? 0;
             if (scrollDuration > this.maxScrollDuration) {
                 throw kerror.get("services", "storage", "scroll_duration_too_great", scroll);
             }
@@ -343,8 +337,8 @@ class ES8 {
             const totalHitsValue = this._getHitsTotalValue(body.hits);
             let remaining;
             if (body._scroll_id) {
-                const ttl = (esRequest.scroll && (0, ms_1.default)(esRequest.scroll)) ||
-                    (0, ms_1.default)(this._config.defaults.scrollTTL);
+                const scrollTTL = this._config.defaults.scrollTTL;
+                const ttl = (scroll && (0, ms_1.default)(scroll)) || (0, ms_1.default)(scrollTTL);
                 await global.kuzzle.ask("core:cache:internal:store", SCROLL_CACHE_PREFIX + global.kuzzle.hash(body._scroll_id), JSON.stringify({
                     collection,
                     fetched: body.hits.hits.length,
@@ -363,6 +357,20 @@ class ES8 {
             throw this._esWrapper.formatESError(error);
         }
     }
+    /**
+     * The comma-separated alias list a multi-target search is run against.
+     *
+     * @param targets - targets already through `assertTargetsAreValid`
+     */
+    _targetsToIndexes(targets) {
+        const indexes = new Set();
+        for (const target of targets) {
+            for (const targetCollection of target.collections) {
+                indexes.add(this._getAlias(target.index, targetCollection));
+            }
+        }
+        return Array.from(indexes).join(",");
+    }
     /**
      * Generate a map that associate an alias to a pair of index and collection
      *
@@ -415,10 +423,15 @@ class ES8 {
                  * find the first alias that exists in the map of aliases associated
                  * to the targets.
                  */
-                const alias = aliases.find((_alias) => aliasToTargets[_alias]);
                 // Retrieve index and collection information based on the matching alias
-                index = aliasToTargets[alias].index;
-                collection = aliasToTargets[alias].collection;
+                for (const _alias of aliases) {
+                    const target = aliasToTargets[_alias];
+                    if (target) {
+                        index = target.index;
+                        collection = target.collection;
+                        break;
+                    }
+                }
             }
             return {
                 _id: hit._id,
@@ -498,7 +511,7 @@ class ES8 {
      */
     async mGet(index, collection, ids) {
         if (ids.length === 0) {
-            return { errors: [], item: [] };
+            return { errors: [], items: [] };
         }
         const esRequest = {
             docs: ids.map((_id) => ({
@@ -566,8 +579,12 @@ class ES8 {
      */
     async create(index, collection, content, { id, refresh, userId = null, injectKuzzleMeta = true, } = {}) {
         (0, requestAssertions_1.assertIsObject)(content);
+        // `document` is optional on an IndexRequest, so the metadata is written
+        // through the local the request holds by reference rather than read back
+        // off the request.
+        const document = content;
         const esRequest = {
-            document: content,
+            document,
             id,
             index: this._getAlias(index, collection),
             op_type: id ? "create" : "index",
@@ -577,7 +594,7 @@ class ES8 {
         assertWellFormedRefresh(esRequest);
         // Add metadata
         if (injectKuzzleMeta) {
-            esRequest.document._kuzzle_info = {
+            document._kuzzle_info = {
                 author: getKuid(userId),
                 createdAt: Date.now(),
                 updatedAt: null,
@@ -589,7 +606,7 @@ class ES8 {
             const body = await this._client.index(esRequest);
             return {
                 _id: body._id,
-                _source: esRequest.document,
+                _source: document,
                 _version: body._version,
             };
         }
@@ -609,8 +626,9 @@ class ES8 {
      * @returns {Promise.<Object>} { _id, _version, _source, created }
      */
     async createOrReplace(index, collection, id, content, { refresh, userId = null, injectKuzzleMeta = true, } = {}) {
+        const document = content;
         const esRequest = {
-            document: content,
+            document,
             id,
             index: this._getAlias(index, collection),
             refresh,
@@ -619,7 +637,7 @@ class ES8 {
         assertWellFormedRefresh(esRequest);
         // Add metadata
         if (injectKuzzleMeta) {
-            esRequest.document._kuzzle_info = {
+            document._kuzzle_info = {
                 author: getKuid(userId),
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
@@ -631,7 +649,7 @@ class ES8 {
             const body = await this._client.index(esRequest);
             return {
                 _id: body._id,
-                _source: esRequest.document,
+                _source: document,
                 _version: body._version,
                 created: body.result === "created", // Needed by the notifier
             };
@@ -652,9 +670,10 @@ class ES8 {
      * @returns {Promise.<{ _id, _version }>}
      */
     async update(index, collection, id, content, { refresh, userId = null, retryOnConflict, injectKuzzleMeta = true, } = {}) {
+        const doc = content;
         const esRequest = {
             _source: true,
-            doc: content,
+            doc,
             id,
             index: this._getAlias(index, collection),
             refresh,
@@ -664,8 +683,8 @@ class ES8 {
         assertWellFormedRefresh(esRequest);
         if (injectKuzzleMeta) {
             // Add metadata
-            esRequest.doc._kuzzle_info = {
-                ...esRequest.doc._kuzzle_info,
+            doc._kuzzle_info = {
+                ...doc._kuzzle_info,
                 updatedAt: Date.now(),
                 updater: getKuid(userId),
             };
@@ -675,7 +694,7 @@ class ES8 {
             const body = await this._client.update(esRequest);
             return {
                 _id: body._id,
-                _source: body.get._source,
+                _source: body.get?._source,
                 _version: body._version,
             };
         }
@@ -696,14 +715,16 @@ class ES8 {
      * @returns {Promise.<{ _id, _version }>}
      */
     async upsert(index, collection, id, content, { defaultValues = {}, refresh, userId = null, retryOnConflict, injectKuzzleMeta = true, } = {}) {
+        const doc = content;
+        const upsert = { ...defaultValues, ...content };
         const esRequest = {
             _source: true,
-            doc: content,
+            doc,
             id,
             index: this._getAlias(index, collection),
             refresh,
             retry_on_conflict: retryOnConflict || this._config.defaults.onUpdateConflictRetries,
-            upsert: { ...defaultValues, ...content },
+            upsert,
         };
         assertNoRouting(esRequest);
         assertWellFormedRefresh(esRequest);
@@ -711,13 +732,13 @@ class ES8 {
         const user = getKuid(userId);
         const now = Date.now();
         if (injectKuzzleMeta) {
-            esRequest.doc._kuzzle_info = {
-                ...esRequest.doc._kuzzle_info,
+            doc._kuzzle_info = {
+                ...doc._kuzzle_info,
                 updatedAt: now,
                 updater: user,
             };
-            esRequest.upsert._kuzzle_info = {
-                ...esRequest.upsert._kuzzle_info,
+            upsert._kuzzle_info = {
+                ...upsert._kuzzle_info,
                 author: user,
                 createdAt: now,
             };
@@ -727,7 +748,7 @@ class ES8 {
             const body = await this._client.update(esRequest);
             return {
                 _id: body._id,
-                _source: body.get._source,
+                _source: body.get?._source,
                 _version: body._version,
                 created: body.result === "created",
             };
@@ -749,8 +770,9 @@ class ES8 {
      */
     async replace(index, collection, id, content, { refresh, userId = null, injectKuzzleMeta = true, } = {}) {
         const alias = this._getAlias(index, collection);
+        const document = content;
         const esRequest = {
-            document: content,
+            document,
             id,
             index: alias,
             refresh,
@@ -759,7 +781,7 @@ class ES8 {
         assertWellFormedRefresh(esRequest);
         if (injectKuzzleMeta) {
             // Add metadata
-            esRequest.document._kuzzle_info = {
+            document._kuzzle_info = {
                 author: getKuid(userId),
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
@@ -843,21 +865,24 @@ class ES8 {
                 });
             }
             this.logger.debug("Delete by query: %o", esRequest);
-            esRequest.refresh = refresh === "wait_for" ? true : refresh;
             const request = {
                 ...esRequest,
-                max_docs: size,
+                // Built in rather than assigned onto `esRequest` afterwards: that
+                // object is spread into the search above, and mutating it after the
+                // fact meant its declared shape and its real one disagreed.
+                refresh: refresh === "wait_for" ? true : refresh,
+                // -1 is Kuzzle's "no limit"; ES wants the property absent rather than
+                // set to undefined after the fact, which was a `number` field being
+                // assigned undefined.
+                max_docs: size === -1 ? undefined : size,
             };
-            if (request.max_docs === -1) {
-                request.max_docs = undefined;
-            }
             const body = await this._client.deleteByQuery(request);
             return {
                 deleted: body.deleted,
                 documents,
-                failures: body.failures.map(({ id, cause }) => ({
+                failures: (body.failures ?? []).map(({ id, cause }) => ({
                     id,
-                    reason: cause.reason,
+                    reason: cause?.reason,
                 })),
                 total: body.total,
             };
@@ -886,26 +911,30 @@ class ES8 {
         try {
             this.logger.debug("DeleteFields document: %o", esRequest);
             const body = await this._client.get(esRequest);
+            const source = body._source;
+            if (source === undefined) {
+                throw kerror.get("services", "storage", "not_found", id, index, collection);
+            }
             for (const field of fields) {
-                if (lodash_1.default.has(body._source, field)) {
-                    lodash_1.default.set(body._source, field, undefined);
+                if (lodash_1.default.has(source, field)) {
+                    lodash_1.default.set(source, field, undefined);
                 }
             }
             const updatedInfos = {
                 updatedAt: Date.now(),
                 updater: getKuid(userId),
             };
-            if (typeof body._source._kuzzle_info === "object") {
-                body._source._kuzzle_info = {
-                    ...body._source._kuzzle_info,
+            if (typeof source._kuzzle_info === "object") {
+                source._kuzzle_info = {
+                    ...source._kuzzle_info,
                     ...updatedInfos,
                 };
             }
             else {
-                body._source._kuzzle_info = updatedInfos;
+                source._kuzzle_info = updatedInfos;
             }
             const newEsRequest = {
-                document: body._source,
+                document: source,
                 id,
                 index: alias,
                 refresh,
@@ -915,7 +944,7 @@ class ES8 {
             const updated = await this._client.index(newEsRequest);
             return {
                 _id: id,
-                _source: body._source,
+                _source: source,
                 _version: updated._version,
             };
         }
@@ -995,8 +1024,9 @@ class ES8 {
         catch (error) {
             throw this._esWrapper.formatESError(error);
         }
-        if (response.failures.length) {
-            const errors = response.failures.map(({ id, cause }) => ({
+        const failures = response.failures ?? [];
+        if (failures.length) {
+            const errors = failures.map(({ id, cause }) => ({
                 cause,
                 id,
             }));
@@ -1031,7 +1061,7 @@ class ES8 {
         }
         const results = [];
         let processed = 0;
-        let scrollId = null;
+        let scrollId;
         try {
             let body = await this._client.search(esRequest);
             const totalHitsValue = this._getHitsTotalValue(body.hits);
@@ -1066,7 +1096,7 @@ class ES8 {
         this._assertValidIndexAndCollection(index);
         let body;
         try {
-            body = await this._client.cat.aliases({ format: "json" });
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1132,11 +1162,11 @@ class ES8 {
             dynamic: mappings.dynamic || this._config.commonMapping.dynamic,
             properties: lodash_1.default.merge(mappings.properties, this._config.commonMapping.properties),
         };
-        esRequest.settings.number_of_replicas =
-            esRequest.settings.number_of_replicas ||
+        settings.number_of_replicas =
+            settings.number_of_replicas ||
                 this._config.defaultSettings.number_of_replicas;
-        esRequest.settings.number_of_shards =
-            esRequest.settings.number_of_shards ||
+        settings.number_of_shards =
+            settings.number_of_shards ||
                 this._config.defaultSettings.number_of_shards;
         try {
             await this._client.indices.create(esRequest);
@@ -1168,7 +1198,7 @@ class ES8 {
         this.logger.debug("Get settings: %o", esRequest);
         try {
             const body = await this._client.indices.getSettings(esRequest);
-            return body[indice].settings.index;
+            return body[indice]?.settings?.index;
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1191,12 +1221,13 @@ class ES8 {
         this.logger.debug("Get mapping: %o", esRequest);
         try {
             const body = await this._client.indices.getMapping(esRequest);
+            const mappings = body[indice]?.mappings ?? {};
             const properties = includeKuzzleMeta
-                ? body[indice].mappings.properties
-                : lodash_1.default.omit(body[indice].mappings.properties, "_kuzzle_info");
+                ? mappings.properties
+                : lodash_1.default.omit(mappings.properties, "_kuzzle_info");
             return {
-                _meta: body[indice].mappings._meta,
-                dynamic: body[indice].mappings.dynamic,
+                _meta: mappings._meta,
+                dynamic: mappings.dynamic,
                 properties,
             };
         }
@@ -1313,10 +1344,12 @@ class ES8 {
             includeKuzzleMeta: true,
         });
         this._checkMappings(mappings);
+        const _meta = mappings._meta || collectionMappings._meta;
+        const dynamic = mappings.dynamic || collectionMappings.dynamic;
         esRequest = {
             ...esRequest,
-            _meta: mappings._meta || collectionMappings._meta,
-            dynamic: mappings.dynamic || collectionMappings.dynamic,
+            _meta,
+            dynamic,
             properties: mappings.properties,
         };
         this.logger.debug("Update mapping: %o", esRequest);
@@ -1328,8 +1361,8 @@ class ES8 {
         }
         const fullProperties = lodash_1.default.merge(collectionMappings.properties, mappings.properties);
         return {
-            _meta: esRequest._meta,
-            dynamic: esRequest.dynamic.toString(),
+            _meta,
+            dynamic: dynamic?.toString(),
             properties: fullProperties,
         };
     }
@@ -1447,34 +1480,18 @@ class ES8 {
          *
          * bulk body can contain more than 10K elements
          */
-        for (let i = 0; i < body.items.length; i++) {
-            const row = body.items[i];
-            const action = Object.keys(row)[0];
-            const item = row[action];
+        for (const row of body.items) {
+            // Elasticsearch answers exactly one action per row; a row carrying none
+            // describes no document, so there is nothing to report on it.
+            const [action = ""] = Object.keys(row);
+            const item = Object.values(row)[0];
+            if (item === undefined) {
+                continue;
+            }
             if (item.status >= 400) {
-                const error = {
-                    _id: item._id,
-                    status: item.status,
-                };
-                // update action contain body in "doc" field
-                // the delete action is not followed by an action payload
-                if (action === "update") {
-                    error._source = documents[idx + 1].doc;
-                    error._source._kuzzle_info = undefined;
-                }
-                else if (action !== "delete") {
-                    error._source = documents[idx + 1];
-                    error._source._kuzzle_info = undefined;
-                }
-                // ES response does not systematicaly include an error object
-                // (e.g. delete action with 404 status)
-                if (item.error) {
-                    error.error = {
-                        reason: item.error.reason,
-                        type: item.error.type,
-                    };
-                }
-                result.errors.push({ [action]: error });
+                result.errors.push({
+                    [action]: this._importError(action, item, documents[idx + 1]),
+                });
             }
             else {
                 result.items.push({
@@ -1490,6 +1507,35 @@ class ES8 {
         /* end critical code section */
         return result;
     }
+    /**
+     * The error entry `import` reports for one rejected bulk row.
+     *
+     * @param action - the bulk action Elasticsearch echoed back
+     * @param item - that action's answer
+     * @param payload - the action's payload, absent for a delete
+     */
+    _importError(action, item, payload) {
+        const error = {
+            _id: item._id,
+            status: item.status,
+        };
+        // update action contain body in "doc" field
+        // the delete action is not followed by an action payload
+        if (action !== "delete") {
+            const source = (action === "update" ? payload?.doc : payload) ?? {};
+            source._kuzzle_info = undefined;
+            error._source = source;
+        }
+        // ES response does not systematicaly include an error object
+        // (e.g. delete action with 404 status)
+        if (item.error) {
+            error.error = {
+                reason: item.error.reason ?? "",
+                type: item.error.type,
+            };
+        }
+        return error;
+    }
     /**
      * Retrieves the complete list of existing collections in the current index
      *
@@ -1501,7 +1547,7 @@ class ES8 {
     async listCollections(index, { includeHidden = false } = {}) {
         let body;
         try {
-            body = await this._client.cat.aliases({ format: "json" });
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1518,7 +1564,7 @@ class ES8 {
     async listIndexes() {
         let body;
         try {
-            body = await this._client.cat.aliases({ format: "json" });
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1535,7 +1581,7 @@ class ES8 {
     async getSchema() {
         let body;
         try {
-            body = await this._client.cat.aliases({ format: "json" });
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1555,7 +1601,7 @@ class ES8 {
     async listAliases() {
         let body;
         try {
-            body = await this._client.cat.aliases({ format: "json" });
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1615,7 +1661,7 @@ class ES8 {
         }
         const deleted = new Set();
         try {
-            const body = await this._client.cat.aliases({ format: "json" });
+            const body = await this._catAliases();
             const esRequest = body.reduce((request, { alias, index: indice }) => {
                 const index = this._extractIndex(alias);
                 if (alias[INDEX_PREFIX_POSITION_IN_ALIAS] !== this._indexPrefix ||
@@ -1706,7 +1752,7 @@ class ES8 {
      */
     async mExists(index, collection, ids) {
         if (ids.length === 0) {
-            return { errors: [], item: [] };
+            return { errors: [], items: [] };
         }
         const esRequest = {
             _source: "false",
@@ -1723,8 +1769,7 @@ class ES8 {
         }
         const errors = [];
         const items = [];
-        for (let i = 0; i < body.docs.length; i++) {
-            const doc = body.docs[i];
+        for (const doc of body.docs) {
             if (!("error" in doc) && doc.found) {
                 items.push(doc._id);
             }
@@ -1768,7 +1813,7 @@ class ES8 {
         const collections = await this.listCollections(index, {
             includeHidden: true,
         });
-        return collections.some((col) => col === HIDDEN_COLLECTION);
+        return collections.includes(HIDDEN_COLLECTION);
     }
     /**
      * Creates multiple documents at once.
@@ -1799,9 +1844,10 @@ class ES8 {
             })
             : { docs: [] };
         const existingDocuments = body.docs;
+        const operations = [];
         const esRequest = {
             index: alias,
-            operations: [],
+            operations,
             refresh,
             timeout,
         };
@@ -1811,11 +1857,11 @@ class ES8 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0, idx = 0; i < extractedDocuments.length; i++) {
-            const document = extractedDocuments[i];
+        let idx = 0;
+        for (const document of extractedDocuments) {
+            const doc = existingDocuments[idx];
             // Documents are retrieved in the same order than we got them from user
-            if (typeof document._id === "string" && existingDocuments[idx]) {
-                const doc = existingDocuments[idx];
+            if (typeof document._id === "string" && doc !== undefined) {
                 if (!("error" in doc) && doc.found) {
                     document._source._kuzzle_info = undefined;
                     rejected.push({
@@ -1828,20 +1874,18 @@ class ES8 {
                     });
                 }
                 else {
-                    esRequest.operations.push({
+                    operations.push({
                         index: {
                             _id: document._id,
                             _index: alias,
                         },
-                    });
-                    esRequest.operations.push(document._source);
+                    }, document._source);
                     toImport.push(document);
                 }
                 idx++;
             }
             else {
-                esRequest.operations.push({ index: { _index: alias } });
-                esRequest.operations.push(document._source);
+                operations.push({ index: { _index: alias } }, document._source);
                 toImport.push(document);
             }
         }
@@ -1871,27 +1915,26 @@ class ES8 {
             };
         }
         const alias = this._getAlias(index, collection);
+        const operations = [];
         const esRequest = {
             index: alias,
-            operations: [],
+            operations,
             refresh,
             timeout,
         };
         const { rejected, extractedDocuments } = this._extractMDocuments(documents, kuzzleMeta);
-        esRequest.operations = [];
         /**
          * @warning Critical code section
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < extractedDocuments.length; i++) {
-            esRequest.operations.push({
+        for (const extractedDocument of extractedDocuments) {
+            operations.push({
                 index: {
-                    _id: extractedDocuments[i]._id,
+                    _id: extractedDocument._id,
                     _index: alias,
                 },
-            });
-            esRequest.operations.push(extractedDocuments[i]._source);
+            }, extractedDocument._source);
         }
         /* end critical code section */
         return this._mExecute(esRequest, extractedDocuments, rejected, {
@@ -1911,10 +1954,11 @@ class ES8 {
      *
      * @returns {Promise.<Object>} { items, errors }
      */
-    async mUpdate(index, collection, documents, { refresh = undefined, retryOnConflict = 0, timeout = undefined, userId = null, } = {}) {
+    async mUpdate(index, collection, documents, { refresh, retryOnConflict = 0, timeout, userId = null, } = {}) {
+        const operations = [];
         const alias = this._getAlias(index, collection), toImport = [], esRequest = {
             index: alias,
-            operations: [],
+            operations,
             refresh,
             timeout,
         }, kuzzleMeta = {
@@ -1928,19 +1972,19 @@ class ES8 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < extractedDocuments.length; i++) {
-            const extractedDocument = extractedDocuments[i];
+        for (const extractedDocument of extractedDocuments) {
             if (typeof extractedDocument._id === "string") {
-                esRequest.operations.push({
+                operations.push({
                     update: {
                         _id: extractedDocument._id,
                         _index: alias,
-                        retry_on_conflict: retryOnConflict || this._config.defaults.onUpdateConflictRetries,
+                        retry_on_conflict: retryOnConflict ||
+                            this._config.defaults.onUpdateConflictRetries,
                     },
-                });
-                // _source: true => makes ES return the updated document source in the
-                // response. Required by the real-time notifier component
-                esRequest.operations.push({
+                }, 
+                // _source: true => makes ES return the updated document source in
+                // the response. Required by the real-time notifier component
+                {
                     _source: true,
                     doc: extractedDocument._source,
                 });
@@ -1984,8 +2028,9 @@ class ES8 {
      */
     async mUpsert(index, collection, documents, { refresh, retryOnConflict = 0, timeout, userId = null, } = {}) {
         const alias = this._getAlias(index, collection);
+        const operations = [];
         const esRequest = {
-            operations: [],
+            operations,
             refresh,
             timeout,
         };
@@ -2014,17 +2059,17 @@ class ES8 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < extractedDocuments.length; i++) {
-            esRequest.operations.push({
+        for (const extractedDocument of extractedDocuments) {
+            operations.push({
                 update: {
-                    _id: extractedDocuments[i]._id,
+                    _id: extractedDocument._id,
                     _index: alias,
                     _source: true,
                     retry_on_conflict: retryOnConflict || this._config.defaults.onUpdateConflictRetries,
                 },
             }, {
-                doc: extractedDocuments[i]._source.changes,
-                upsert: extractedDocuments[i]._source.default,
+                doc: extractedDocument._source.changes,
+                upsert: extractedDocument._source.default,
             });
             // _source: true
             // Makes ES return the updated document source in the response.
@@ -2077,8 +2122,9 @@ class ES8 {
             index: alias,
         });
         const existingDocuments = body.docs;
+        const operations = [];
         const esRequest = {
-            operations: [],
+            operations,
             refresh,
             timeout,
         };
@@ -2088,18 +2134,19 @@ class ES8 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < extractedDocuments.length; i++) {
-            const document = extractedDocuments[i];
+        for (const [i, document] of extractedDocuments.entries()) {
             // Documents are retrieved in the same order than we got them from user
             const doc = existingDocuments[i];
-            if (!("error" in doc) && doc?.found) {
-                esRequest.operations.push({
+            // `doc` used to be read with `"error" in doc` and only then with `?.`:
+            // a shorter mget answer than the request reached the `in` first, which
+            // throws on undefined.
+            if (doc !== undefined && !("error" in doc) && doc.found) {
+                operations.push({
                     index: {
                         _id: document._id,
                         _index: alias,
                     },
-                });
-                esRequest.operations.push(document._source);
+                }, document._source);
                 toImport.push(document);
             }
             else {
@@ -2136,8 +2183,7 @@ class ES8 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < ids.length; i++) {
-            const _id = ids[i];
+        for (const _id of ids) {
             if (typeof _id === "string") {
                 validIds.push(_id);
             }
@@ -2158,8 +2204,7 @@ class ES8 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < validIds.length; i++) {
-            const validId = validIds[i];
+        for (const validId of validIds) {
             const item = items[idx];
             if (item && item._id === validId) {
                 query.ids.values.push(validId);
@@ -2198,10 +2243,10 @@ class ES8 {
         if (this._hasExceededLimit(limits, documents)) {
             return kerror.reject("services", "storage", "write_limit_exceeded");
         }
-        let body = { items: [] };
+        let items = [];
         if (documents.length > 0) {
             try {
-                body = await this._client.bulk(esRequest);
+                ({ items } = await this._client.bulk(esRequest));
             }
             catch (error) {
                 throw this._esWrapper.formatESError(error);
@@ -2213,32 +2258,21 @@ class ES8 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < body.items.length; i++) {
-            const item = body.items[i];
-            const result = item[Object.keys(item)[0]];
+        for (const [i, item] of items.entries()) {
+            const result = Object.values(item)[0];
+            const document = documents[i];
+            // An answer carries exactly one result per document sent; a row without
+            // its counterpart is one neither branch below could describe.
+            if (result === undefined || document === undefined) {
+                continue;
+            }
             if (result.status >= 400) {
-                if (result.status === 404) {
-                    partialErrors.push({
-                        document: {
-                            _id: documents[i]._id,
-                            body: documents[i]._source,
-                        },
-                        reason: "document not found",
-                        status: result.status,
-                    });
-                }
-                else {
-                    partialErrors.push({
-                        document: documents[i],
-                        reason: result.error.reason,
-                        status: result.status,
-                    });
-                }
+                partialErrors.push(this._mExecuteRejection(result, document));
             }
             else {
                 successes.push({
                     _id: result._id,
-                    _source: source ? documents[i]._source : undefined,
+                    _source: source ? document._source : undefined,
                     _version: result._version,
                     created: result.result === "created",
                     get: result.get,
@@ -2253,6 +2287,29 @@ class ES8 {
             items: successes,
         };
     }
+    /**
+     * The partial-error entry `_mExecute` reports for one rejected bulk row.
+     *
+     * A 404 answers no reason of its own, and reports the document by id and
+     * body rather than whole, which is what the m* callers read back.
+     */
+    _mExecuteRejection(result, document) {
+        if (result.status === 404) {
+            return {
+                document: {
+                    _id: document._id,
+                    body: document._source,
+                },
+                reason: "document not found",
+                status: result.status,
+            };
+        }
+        return {
+            document,
+            reason: result.error?.reason,
+            status: result.status,
+        };
+    }
     /**
      * Extracts, injects metadata and validates documents contained
      * in a Request
@@ -2274,8 +2331,7 @@ class ES8 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < documents.length; i++) {
-            const document = documents[i];
+        for (const document of documents) {
             if (!(0, safeObject_1.isPlainObject)(document.body) && !prepareMUpsert) {
                 rejected.push({
                     document,
@@ -2406,17 +2462,15 @@ class ES8 {
      */
     async _getIndice(index, collection) {
         const alias = `${ALIAS_PREFIX}${this._indexPrefix}${index}${NAME_SEPARATOR}${collection}`;
-        const body = await this._client.cat.aliases({
-            format: "json",
-            name: alias,
-        });
-        if (body.length < 1) {
+        const body = await this._catAliases(alias);
+        const [record] = body;
+        if (record === undefined) {
             throw kerror.get("services", "storage", "unknown_index_collection");
         }
         else if (body.length > 1) {
             throw kerror.get("services", "storage", "multiple_indice_alias", `"alias" starting with "${ALIAS_PREFIX}"`, '"indices"');
         }
-        return body[0].index;
+        return record.index;
     }
     /**
      * Given an ES Request returns the settings of the corresponding indice.
@@ -2428,7 +2482,7 @@ class ES8 {
     async _getSettings(esRequest) {
         const response = await this._client.indices.getSettings(esRequest);
         const index = esRequest.index;
-        return response[index].settings;
+        return response[index]?.settings;
     }
     /**
      * Given index + collection, returns an available indice name.
@@ -2471,11 +2525,27 @@ class ES8 {
      */
     async _getAliasFromIndice(indice) {
         const body = await this._client.indices.getAlias({ index: indice });
-        const aliases = Object.keys(body[indice].aliases).filter((alias) => alias.startsWith(ALIAS_PREFIX));
-        if (aliases.length < 1) {
+        const indiceAliases = body[indice]?.aliases ?? {};
+        const [first, ...others] = Object.keys(indiceAliases).filter((alias) => alias.startsWith(ALIAS_PREFIX));
+        // The non-empty tuple is what lets every caller read aliases[0] without a
+        // guard the throw below already made redundant.
+        if (first === undefined) {
             throw kerror.get("services", "storage", "unknown_index_collection");
         }
-        return aliases;
+        return [first, ...others];
+    }
+    /**
+     * `cat.aliases` declares `alias` and `index` as optional. Defaulting them
+     * once here is what lets every caller index into an alias without repeating
+     * the check — and an empty alias fails the index-prefix test every caller
+     * applies, which is what a row without one used to throw on.
+     */
+    async _catAliases(name) {
+        const body = await this._client.cat.aliases(name === undefined ? { format: "json" } : { format: "json", name });
+        return body.map(({ alias, index }) => ({
+            alias: alias ?? "",
+            index: index ?? "",
+        }));
     }
     /**
      * Check for each indice whether it has an alias or not.
@@ -2487,11 +2557,13 @@ class ES8 {
     async generateMissingAliases() {
         try {
             const body = await this._client.cat.indices({ format: "json" });
-            const indices = body.map(({ index: indice }) => indice);
+            const indices = body.flatMap(({ index: indice }) => indice === undefined ? [] : [indice]);
             const aliases = await this.listAliases();
             const indicesWithoutAlias = indices.filter((indice) => indice[INDEX_PREFIX_POSITION_IN_INDICE] === this._indexPrefix &&
                 !aliases.some((alias) => alias.indice === indice));
-            const esRequest = { body: { actions: [] } };
+            const esRequest = {
+                body: { actions: [] },
+            };
             for (const indice of indicesWithoutAlias) {
                 esRequest.body.actions.push({
                     add: { alias: `${ALIAS_PREFIX}${indice}`, index: indice },
@@ -2551,16 +2623,16 @@ class ES8 {
     _extractSchema(aliases, { includeHidden = false } = {}) {
         const schema = {};
         for (const alias of aliases) {
-            const [indexName, collectionName] = alias
+            // `split` always yields a first element; the defaults are what make that
+            // readable to the compiler.
+            const [indexName = "", collectionName = ""] = alias
                 .slice(INDEX_PREFIX_POSITION_IN_ALIAS + 1)
                 .split(NAME_SEPARATOR);
             if (alias[INDEX_PREFIX_POSITION_IN_ALIAS] === this._indexPrefix &&
                 (collectionName !== HIDDEN_COLLECTION || includeHidden)) {
-                if (!schema[indexName]) {
-                    schema[indexName] = [];
-                }
-                if (!schema[indexName].includes(collectionName)) {
-                    schema[indexName].push(collectionName);
+                const collections = (schema[indexName] ?? (schema[indexName] = []));
+                if (!collections.includes(collectionName)) {
+                    collections.push(collectionName);
                 }
             }
         }
@@ -2655,7 +2727,7 @@ class ES8 {
      *
      * @param {Object} searchBody - ES search body (with query, aggregations, sort, etc)
      */
-    _sanitizeSearchBody(searchBody) {
+    _sanitizeSearchBody(searchBody = {}) {
         // Only allow a whitelist of top level properties
         for (const key of Object.keys(searchBody)) {
             if (searchBody[key] !== undefined && !this.searchBodyKeys.includes(key)) {
@@ -2776,7 +2848,7 @@ class ES8 {
                     await bluebird_1.default.delay(1000);
                 }
             }
-            catch (e) {
+            catch {
                 await bluebird_1.default.delay(1000);
             }
         }
@@ -2809,7 +2881,7 @@ class ES8 {
         const actionNames = ["index", "create", "update", "delete"];
         for (let i = 0; i < esRequest.operations.length; i++) {
             const item = esRequest.operations[i];
-            const action = Object.keys(item)[0];
+            const action = Object.keys(item)[0] ?? "";
             if (actionNames.indexOf(action) !== -1) {
                 lastAction = action;
                 item[action]._index = alias;
@@ -2837,7 +2909,7 @@ class ES8 {
         if (typeof hits.total === "number") {
             return hits.total;
         }
-        return hits.total.value;
+        return hits.total?.value ?? 0;
     }
     _getRandomNumber(number) {
         return (0, name_generator_1.randomNumber)(number);
@@ -2922,10 +2994,11 @@ function _isObjectNameValid(name) {
     if (name === "_all") {
         return false;
     }
-    let valid = true;
-    for (let i = 0; valid && i < FORBIDDEN_CHARS.length; i++) {
-        valid = !name.includes(FORBIDDEN_CHARS[i]);
+    for (const forbiddenChar of FORBIDDEN_CHARS) {
+        if (name.includes(forbiddenChar)) {
+            return false;
+        }
     }
-    return valid;
+    return true;
 }
 //# sourceMappingURL=elasticsearch.js.map