kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/service/storage/7/esWrapper.d.ts

@@ -1,19 +1,36 @@
-export = ESWrapper;
+import type { Client } from "sdk-es7";
+import type { JSONObject } from "../../../types/JSONObject";
+import { KuzzleError } from "../../../kerror/errors";
+/**
+ * What the Elasticsearch client throws: an Error, carrying the server's
+ * response on `meta` for the ones that came back from the cluster. `catch`
+ * hands callers `unknown`, and this is the shape every reader below assumes.
+ */
+type ThrownESError = Error & {
+    meta?: JSONObject;
+    body?: JSONObject;
+};
+/**
+ * One that came back from the cluster rather than from the client itself, so
+ * its `meta` is present — which is what `formatESError` checks before handing
+ * it to the handlers below.
+ */
+type ThrownESResponseError = ThrownESError & {
+    meta: JSONObject;
+};
 declare class ESWrapper {
-    constructor(client: any);
-    client: any;
+    client: Client;
+    constructor(client: Client);
     /**
      * Transforms raw ES errors into a normalized Kuzzle version
      *
-     * @param {Error} error
-     * @returns {KuzzleError}
+     * @param error
      */
-    formatESError(error: Error): KuzzleError;
-    reject(error: any): Bluebird<never>;
-    _handleConflictError(error: any, message: any): KuzzleError;
-    _handleNotFoundError(error: any, message: any): KuzzleError;
-    _handleBadRequestError(error: any, message: any): KuzzleError;
-    _handleUnknownError(error: any, message: any): KuzzleError;
+    formatESError(error: unknown): KuzzleError;
+    reject(error: unknown): Promise<never>;
+    _handleConflictError(error: ThrownESResponseError, message: string): KuzzleError;
+    _handleNotFoundError(error: ThrownESResponseError, message: string): KuzzleError;
+    _handleBadRequestError(error: ThrownESResponseError, message: string): KuzzleError;
+    _handleUnknownError(error: ThrownESError, message: string): KuzzleError;
 }
-import { KuzzleError } from "../../../kerror/errors/kuzzleError";
-import Bluebird = require("bluebird");
+export = ESWrapper;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,18 +19,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 /* eslint sort-keys: 0 */
-"use strict";
-const Bluebird = require("bluebird");
-const _ = require("lodash");
-const es = require("sdk-es7");
-const { KuzzleError } = require("../../../kerror/errors");
-const debug = require("../../../util/debug")("kuzzle:services:storage:ESCommon");
-const kerror = require("../../../kerror").wrap("services", "storage");
+const node_util_1 = require("node:util");
+const bluebird_1 = __importDefault(require("bluebird"));
+const get_1 = __importDefault(require("lodash/get"));
+const sdk_es7_1 = require("sdk-es7");
+const errors_1 = require("../../../kerror/errors");
+const debug_1 = __importDefault(require("../../../util/debug"));
+const kerror_1 = require("../../../kerror");
+const debug = (0, debug_1.default)("kuzzle:services:storage:ESCommon");
+const kerror = (0, kerror_1.wrap)("services", "storage");
+function isResponseError(error) {
+    return Boolean(error.meta);
+}
 const errorMessagesMapping = [
     {
         regex: /^\[es_rejected_execution_exception] rejected execution .*? on EsThreadPoolExecutor\[(.*?), .*$/,
-        subCode: "too_many_operations",
+        subcode: "too_many_operations",
         getPlaceholders: (esError, matches) => [matches[1]],
     },
     {
@@ -89,7 +98,7 @@ const errorMessagesMapping = [
     },
     {
         // [index_not_found_exception] no such index, with { resource.type=index_or_alias & resource.id=foso & index=foso }
-        regex: /^no such index \[([%&])(.*)\.(.*)\]$/,
+        regex: /^no such index \[([%&])([^\]]*)\.([^.\]]*)\]$/,
         subcode: "unknown_collection",
         getPlaceholders: (esError, matches) => [matches[2], matches[3]],
     },
@@ -122,9 +131,9 @@ const errorMessagesMapping = [
         subcode: "strict_mapping_rejection",
         getPlaceholders: (esError, matches) => {
             // "/%26index.collection/_doc"
-            const esPath = esError.meta.meta.request.params.path;
+            const esPath = (0, get_1.default)(esError, "meta.meta.request.params.path", "");
             // keep only "index"
-            const index = esPath.split(".")[0].split("%26")[1];
+            const index = esPath.split(".")[0]?.split("%26")[1];
             // keep only "collection"
             const collection = esPath.substr(esPath.indexOf(".") + 1).split("/")[0];
             return [matches[1], index, collection];
@@ -150,47 +159,58 @@ class ESWrapper {
     /**
      * Transforms raw ES errors into a normalized Kuzzle version
      *
-     * @param {Error} error
-     * @returns {KuzzleError}
+     * @param error
      */
     formatESError(error) {
-        if (error instanceof KuzzleError) {
+        if (error instanceof errors_1.KuzzleError) {
             return error;
         }
+        // `catch` answers `unknown`, and a rejected client promise can in principle
+        // carry anything. Everything below reads an Error's shape, so that is what
+        // it gets — without asserting that whatever arrived already was one.
+        // `inspect`, not `String`: a thrown object stringifies to "[object
+        // Object]", which is the one thing the message must not say.
+        const esError = error instanceof Error ? error : new Error((0, node_util_1.inspect)(error));
         global.kuzzle.emit("services:storage:error", {
-            message: `Elasticsearch Client error: ${error.message}`,
+            message: `Elasticsearch Client error: ${esError.message}`,
             // /!\ not all ES error classes have a "meta" property
-            meta: error.meta || null,
-            stack: error.stack,
+            meta: esError.meta || null,
+            stack: esError.stack,
         });
-        if (error instanceof es.errors.NoLivingConnectionsError) {
+        if (error instanceof sdk_es7_1.errors.NoLivingConnectionsError) {
             throw kerror.get("not_connected");
         }
-        const message = _.get(error, "meta.body.error.reason", error.message);
+        const message = (0, get_1.default)(esError, "meta.body.error.reason", esError.message);
         // Try to match a known elasticsearch error
         for (const betterError of errorMessagesMapping) {
             const matches = message.match(betterError.regex);
             if (matches) {
-                return kerror.get(betterError.subcode, ...betterError.getPlaceholders(error, matches));
+                return kerror.get(betterError.subcode, ...betterError.getPlaceholders(esError, matches));
             }
         }
         // Try to match using error codes
-        if (error.meta) {
-            switch (error.meta.statusCode) {
+        // `meta` is what tells a cluster response from a client-side failure, so
+        // the three handlers below are declared to require it rather than
+        // re-checking it four times each. The error itself is handed over, never a
+        // copy: the client's `ResponseError` exposes `body` as a prototype getter,
+        // which a spread does not carry — and without it every missing document
+        // answered `unexpected_not_found` instead of `not_found`.
+        if (isResponseError(esError)) {
+            switch (esError.meta.statusCode) {
                 case 400:
-                    return this._handleBadRequestError(error, message);
+                    return this._handleBadRequestError(esError, message);
                 case 404:
-                    return this._handleNotFoundError(error, message);
+                    return this._handleNotFoundError(esError, message);
                 case 409:
-                    return this._handleConflictError(error, message);
+                    return this._handleConflictError(esError, message);
                 default:
                     break;
             }
         }
-        return this._handleUnknownError(error, message);
+        return this._handleUnknownError(esError, message);
     }
     reject(error) {
-        return Bluebird.reject(this.formatESError(error));
+        return bluebird_1.default.reject(this.formatESError(error));
     }
     _handleConflictError(error, message) {
         debug('unhandled "Conflict" elasticsearch error: %a', error);
@@ -198,46 +218,47 @@ class ESWrapper {
     }
     _handleNotFoundError(error, message) {
         let errorMessage = message;
-        if (!error.body._index) {
+        const indice = (0, get_1.default)(error, "body._index");
+        if (!indice) {
             return kerror.get("unexpected_not_found", errorMessage);
         }
         // _index= "&nyc-open-data.yellow-taxi"
-        const index = error.body._index.split(".")[0].slice(1);
-        const collection = error.body._index.split(".")[1];
+        const index = indice.split(".")[0]?.slice(1);
+        const collection = indice.split(".")[1];
         // 404 on a GET document
-        if (error.body.found === false) {
+        if (error.body?.found === false) {
             return kerror.get("not_found", error.body._id, index, collection);
         }
         // 404 on DELETE document (ES error payloads are so cool!)
         if (error.meta.body._id) {
             return kerror.get("not_found", error.meta.body._id, index, collection);
         }
-        if (error.meta.body && error.meta.body.error) {
+        if (error.meta.body?.error) {
             errorMessage = error.meta.body.error
                 ? `${error.meta.body.error.reason}: ${error.meta.body.error["resource.id"]}`
-                : `${error.message}: ${error.body._id}`;
+                : `${error.message}: ${error.body?._id}`;
         }
         debug('unhandled "NotFound" elasticsearch error: %a', error);
         return kerror.get("unexpected_not_found", errorMessage);
     }
     _handleBadRequestError(error, message) {
         let errorMessage = message;
-        if (error.meta.body && error.meta.body.error) {
+        if (error.meta.body?.error) {
             errorMessage = error.meta.body.error.root_cause
                 ? error.meta.body.error.root_cause[0].reason
                 : error.meta.body.error.reason;
             // empty query throws exception with ES 7
             if (error.meta.body.error.type === "parsing_exception" &&
-                _.get(error, "meta.body.error.caused_by.type") ===
+                (0, get_1.default)(error, "meta.body.error.caused_by.type") ===
                     "illegal_argument_exception") {
                 errorMessage = error.meta.body.error.caused_by.reason;
             }
         }
-        debug('unhandled "BadRequest" elasticsearch error: %a', _.get(error, "meta.body.error.reason", error.message));
+        debug('unhandled "BadRequest" elasticsearch error: %a', (0, get_1.default)(error, "meta.body.error.reason", error.message));
         return kerror.get("unexpected_bad_request", errorMessage);
     }
     _handleUnknownError(error, message) {
-        debug("unhandled elasticsearch error (unhandled type: %s): %o", _.get(error, "error.meta.statusCode", "<no status code>"), error);
+        debug("unhandled elasticsearch error (unhandled type: %s): %o", (0, get_1.default)(error, "error.meta.statusCode", "<no status code>"), error);
         return kerror.get("unexpected_error", message);
     }
 }