kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -102,8 +102,6 @@ class ES7 {
         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 ES7 {
         await this.waitForElasticsearch();
         this._esWrapper = new esWrapper_1.default(this._client);
         const { body: { version }, } = await this._client.info();
-        if (version &&
-            !semver_1.default.satisfies(semver_1.default.coerce(version.number), ">= 7.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, ">= 7.0.0")) {
+                throw kerror.get("services", "storage", "version_mismatch", version.number);
+            }
         }
         this._esVersion = version;
     }
@@ -216,7 +216,7 @@ class ES7 {
         const { body } = await this._client.indices.stats(esRequest);
         const indexes = {};
         let size = 0;
-        for (const [indice, indiceInfo] of Object.entries(body.indices)) {
+        for (const [indice, indiceInfo] of Object.entries(body.indices ?? {})) {
             const infos = indiceInfo;
             // Ignore non-Kuzzle indices
             if (!indice.startsWith(PRIVATE_PREFIX) &&
@@ -231,19 +231,17 @@ class ES7 {
                 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 {
@@ -270,7 +268,7 @@ class ES7 {
         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);
             }
@@ -313,16 +311,12 @@ class ES7 {
     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 = {
@@ -334,7 +328,7 @@ class ES7 {
             trackTotalHits: 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);
             }
@@ -363,6 +357,20 @@ class ES7 {
             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 ES7 {
                  * 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 ES7 {
      */
     async mGet(index, collection, ids) {
         if (ids.length === 0) {
-            return { errors: [], item: [] };
+            return { errors: [], items: [] };
         }
         const esRequest = {
             body: {
@@ -847,7 +860,7 @@ class ES7 {
             return {
                 deleted: body.deleted,
                 documents,
-                failures: body.failures.map(({ shardId, reason }) => ({
+                failures: (body.failures ?? []).map(({ shardId, reason }) => ({
                     reason,
                     shardId,
                 })),
@@ -954,10 +967,14 @@ class ES7 {
      * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
      */
     async bulkUpdateByQuery(index, collection, query, changes, { refresh = false, } = {}) {
+        // `body` is optional on the request params, so the script is written
+        // through the local the request holds by reference rather than read back
+        // off the request.
+        const requestBody = {
+            query: this._sanitizeSearchBody({ query }).query,
+        };
         const esRequest = {
-            body: {
-                query: this._sanitizeSearchBody({ query }).query,
-            },
+            body: requestBody,
             index: this._getAlias(index, collection),
             refresh,
         };
@@ -971,7 +988,7 @@ class ES7 {
             script.params[key] = value;
         }
         if (script.source !== "") {
-            esRequest.body.script = script;
+            requestBody.script = script;
         }
         this.logger.debug("Bulk Update by query: %o", esRequest);
         let response;
@@ -981,8 +998,9 @@ class ES7 {
         catch (error) {
             throw this._esWrapper.formatESError(error);
         }
-        if (response.body.failures.length) {
-            const errors = response.body.failures.map(({ shardId, reason }) => ({
+        const failures = response.body.failures ?? [];
+        if (failures.length) {
+            const errors = failures.map(({ shardId, reason }) => ({
                 reason,
                 shardId,
             }));
@@ -1018,7 +1036,7 @@ class ES7 {
         const client = this._client;
         let results = [];
         let processed = 0;
-        let scrollId = null;
+        let scrollId;
         try {
             results = await new bluebird_1.default((resolve, reject) => {
                 this._client.search(esRequest, async function getMoreUntilDone(error, { body: { hits, _scroll_id } }) {
@@ -1063,7 +1081,7 @@ class ES7 {
         this._assertValidIndexAndCollection(index);
         let body;
         try {
-            body = (await this._client.cat.aliases({ format: "json" })).body;
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1109,14 +1127,15 @@ class ES7 {
         finally {
             await mutex.unlock();
         }
-        const esRequest = {
-            body: {
-                aliases: {
-                    [this._getAlias(index, collection)]: {},
-                },
-                mappings: {},
-                settings,
+        const requestBody = {
+            aliases: {
+                [this._getAlias(index, collection)]: {},
             },
+            mappings: {},
+            settings,
+        };
+        const esRequest = {
+            body: requestBody,
             index: await this._getAvailableIndice(index, collection),
             wait_for_active_shards: await this._getWaitForActiveShards(),
         };
@@ -1126,16 +1145,16 @@ class ES7 {
             return this.updateCollection(index, collection, { mappings, settings });
         }
         this._checkMappings(mappings);
-        esRequest.body.mappings = {
+        requestBody.mappings = {
             _meta: mappings._meta || this._config.commonMapping._meta,
             dynamic: mappings.dynamic || this._config.commonMapping.dynamic,
             properties: lodash_1.default.merge(mappings.properties, this._config.commonMapping.properties),
         };
-        esRequest.body.settings.number_of_replicas =
-            esRequest.body.settings.number_of_replicas ||
+        settings.number_of_replicas =
+            settings.number_of_replicas ||
                 this._config.defaultSettings.number_of_replicas;
-        esRequest.body.settings.number_of_shards =
-            esRequest.body.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);
@@ -1450,34 +1469,18 @@ class ES7 {
          *
          * 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({
@@ -1493,6 +1496,35 @@ class ES7 {
         /* 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
      *
@@ -1504,7 +1536,7 @@ class ES7 {
     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);
@@ -1521,7 +1553,7 @@ class ES7 {
     async listIndexes() {
         let body;
         try {
-            ({ body } = await this._client.cat.aliases({ format: "json" }));
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1538,7 +1570,7 @@ class ES7 {
     async getSchema() {
         let body;
         try {
-            ({ body } = await this._client.cat.aliases({ format: "json" }));
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1558,7 +1590,7 @@ class ES7 {
     async listAliases() {
         let body;
         try {
-            ({ body } = await this._client.cat.aliases({ format: "json" }));
+            body = await this._catAliases();
         }
         catch (error) {
             throw this._esWrapper.formatESError(error);
@@ -1618,7 +1650,7 @@ class ES7 {
         }
         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 ||
@@ -1712,7 +1744,7 @@ class ES7 {
      */
     async mExists(index, collection, ids) {
         if (ids.length === 0) {
-            return { errors: [], item: [] };
+            return { errors: [], items: [] };
         }
         const esRequest = {
             _source: "false",
@@ -1776,7 +1808,7 @@ class ES7 {
         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.
@@ -1819,8 +1851,8 @@ class ES7 {
          *
          * 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) {
             // Documents are retrieved in the same order than we got them from user
             if (typeof document._id === "string" && existingDocuments[idx]) {
                 if (existingDocuments[idx].found) {
@@ -1840,15 +1872,13 @@ class ES7 {
                             _id: document._id,
                             _index: alias,
                         },
-                    });
-                    esRequest.body.push(document._source);
+                    }, document._source);
                     toImport.push(document);
                 }
                 idx++;
             }
             else {
-                esRequest.body.push({ index: { _index: alias } });
-                esRequest.body.push(document._source);
+                esRequest.body.push({ index: { _index: alias } }, document._source);
                 toImport.push(document);
             }
         }
@@ -1885,20 +1915,18 @@ class ES7 {
             timeout,
         };
         const { rejected, extractedDocuments } = this._extractMDocuments(documents, kuzzleMeta);
-        esRequest.body = [];
         /**
          * @warning Critical code section
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < extractedDocuments.length; i++) {
+        for (const extractedDocument of extractedDocuments) {
             esRequest.body.push({
                 index: {
-                    _id: extractedDocuments[i]._id,
+                    _id: extractedDocument._id,
                     _index: alias,
                 },
-            });
-            esRequest.body.push(extractedDocuments[i]._source);
+            }, extractedDocument._source);
         }
         /* end critical code section */
         return this._mExecute(esRequest, extractedDocuments, rejected, {
@@ -1918,7 +1946,7 @@ class ES7 {
      *
      * @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 alias = this._getAlias(index, collection), toImport = [], esRequest = {
             body: [],
             index: alias,
@@ -1935,19 +1963,18 @@ class ES7 {
          *
          * 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") {
+                // _source: true => makes ES return the updated document source in the
+                // response. Required by the real-time notifier component
                 esRequest.body.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.body.push({
+                }, {
                     _source: true,
                     doc: extractedDocument._source,
                 });
@@ -2021,17 +2048,17 @@ class ES7 {
          *
          * request can contain more than 10K elements
          */
-        for (let i = 0; i < extractedDocuments.length; i++) {
+        for (const extractedDocument of extractedDocuments) {
             esRequest.body.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.
@@ -2095,8 +2122,7 @@ class ES7 {
          *
          * 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
             if (existingDocuments[i]?.found) {
                 esRequest.body.push({
@@ -2104,8 +2130,7 @@ class ES7 {
                         _id: document._id,
                         _index: alias,
                     },
-                });
-                esRequest.body.push(document._source);
+                }, document._source);
                 toImport.push(document);
             }
             else {
@@ -2164,8 +2189,7 @@ class ES7 {
          *
          * 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);
@@ -2204,48 +2228,38 @@ class ES7 {
         if (this._hasExceededLimit(limits, documents)) {
             return kerror.reject("services", "storage", "write_limit_exceeded");
         }
-        let response = { body: { items: [] } };
+        let items = [];
         if (documents.length > 0) {
             try {
-                response = await this._client.bulk(esRequest);
+                ({
+                    body: { items },
+                } = await this._client.bulk(esRequest));
             }
             catch (error) {
                 throw this._esWrapper.formatESError(error);
             }
         }
-        const body = response.body;
         const successes = [];
         /**
          * @warning Critical code section
          *
          * 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,
@@ -2260,6 +2274,29 @@ class ES7 {
             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
@@ -2281,8 +2318,7 @@ class ES7 {
          *
          * 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,
@@ -2414,17 +2450,15 @@ class ES7 {
      */
     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.
@@ -2478,13 +2512,30 @@ class ES7 {
      * @returns {String} Alias name (eg: '@&nepali.liia')
      * @throws If there is not exactly one alias associated that is prefixed with @
      */
+    /**
+     * `cat.aliases` answers untyped rows whose `alias` and `index` the client
+     * declares 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 ?? "",
+        }));
+    }
     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];
     }
     /**
      * Check for each indice whether it has an alias or not.
@@ -2496,11 +2547,13 @@ class ES7 {
     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 },
@@ -2560,16 +2613,16 @@ class ES7 {
     _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);
                 }
             }
         }
@@ -2665,7 +2718,7 @@ class ES7 {
      *
      * @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)) {
@@ -2786,7 +2839,7 @@ class ES7 {
                     await bluebird_1.default.delay(1000);
                 }
             }
-            catch (e) {
+            catch {
                 await bluebird_1.default.delay(1000);
             }
         }
@@ -2817,9 +2870,8 @@ class ES7 {
          */
         let lastAction = "";
         const actionNames = ["index", "create", "update", "delete"];
-        for (let i = 0; i < esRequest.body.length; i++) {
-            const item = esRequest.body[i];
-            const action = Object.keys(item)[0];
+        for (const item of esRequest.body) {
+            const action = Object.keys(item)[0] ?? "";
             if (actionNames.indexOf(action) !== -1) {
                 lastAction = action;
                 item[action]._index = alias;
@@ -2926,10 +2978,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