kuzzle 2.32.0-elasticsearch-8.1 → 2.32.0

package/README.md

@@ -4,9 +4,6 @@
 <p align="center">
   <img alt="GitHub branch checks state" src="https://img.shields.io/github/checks-status/kuzzleio/kuzzle/master">
   <img alt="Sonarcloud" src="https://sonarcloud.io/api/project_badges/measure?project=kuzzleio_kuzzle&metric=alert_status&branch=master">
-  <a href="https://codecov.io/gh/kuzzleio/kuzzle">
-    <img src="https://codecov.io/gh/kuzzleio/kuzzle/branch/master/graph/badge.svg?token=jOrGhzslSM"/>
-  </a>
   <a href="https://lgtm.com/projects/g/kuzzleio/kuzzle/context:javascript">
     <img src="https://img.shields.io/lgtm/grade/javascript/g/kuzzleio/kuzzle.svg?logo=lgtm&logoWidth=18" />
   </a>

package/index.d.ts

@@ -13,3 +13,4 @@ export * from "./lib/core/shared/ObjectRepository";
 export * from "./lib/core/shared/store";
 export * from "./lib/core/cache/cacheDbEnum";
 export * from "./lib/core/storage/storeScopeEnum";
+export * from "./lib/service/storage/commons/queryTranslator";

package/index.js

@@ -31,4 +31,5 @@ __exportStar(require("./lib/core/shared/ObjectRepository"), exports);
 __exportStar(require("./lib/core/shared/store"), exports);
 __exportStar(require("./lib/core/cache/cacheDbEnum"), exports);
 __exportStar(require("./lib/core/storage/storeScopeEnum"), exports);
+__exportStar(require("./lib/service/storage/commons/queryTranslator"), exports);
 //# sourceMappingURL=index.js.map

package/lib/kerror/index.js

@@ -169,7 +169,7 @@ function rawGetFrom(domains, source, domain, subdomain, error, ...placeholders)
     const derivedError = rawGet(domains, domain, subdomain, error, ...placeholders);
     // If a stacktrace is present, we need to modify the first line because it
     // still contains the original error message
-    if (derivedError.stack && derivedError.stack.length && source.stack) {
+    if (derivedError?.stack?.length && source?.stack) {
         const stackArray = source.stack.split("\n");
         stackArray.shift();
         derivedError.stack = [

package/lib/service/storage/7/elasticsearch.d.ts

@@ -3,7 +3,7 @@ import { RequestParams, Client } from "sdk-es7";
 import { TypeMapping } from "sdk-es7/api/types";
 import { JSONObject, KRequestBody, KRequestParams } from "../../../types/storage/7/Elasticsearch";
 import ESWrapper from "./esWrapper";
-import QueryTranslator from "../commons/queryTranslator";
+import { QueryTranslator } from "../commons/queryTranslator";
 import { storeScopeEnum } from "../../../core/storage/storeScopeEnum";
 /**
  * @param {Kuzzle} kuzzle kuzzle instance

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

@@ -55,7 +55,7 @@ const ms_1 = __importDefault(require("ms"));
 const semver_1 = __importDefault(require("semver"));
 const debug_1 = __importDefault(require("../../../util/debug"));
 const esWrapper_1 = __importDefault(require("./esWrapper"));
-const queryTranslator_1 = __importDefault(require("../commons/queryTranslator"));
+const queryTranslator_1 = require("../commons/queryTranslator");
 const didYouMean_1 = __importDefault(require("../../../util/didYouMean"));
 const kerror = __importStar(require("../../../kerror"));
 const requestAssertions_1 = require("../../../util/requestAssertions");
@@ -106,7 +106,7 @@ class ES7 {
         this._client = null;
         this._esWrapper = null;
         this._esVersion = null;
-        this._translator = new queryTranslator_1.default();
+        this._translator = new queryTranslator_1.QueryTranslator();
         // Allowed root key of a search query
         this.searchBodyKeys = [
             "aggregations",

package/lib/service/storage/8/elasticsearch.d.ts

@@ -2,7 +2,7 @@ import _ from "lodash";
 import { Client, estypes } from "sdk-es8";
 import { InfoResult, JSONObject, KRequestBody, KRequestParams, KStats, KUpdateResponse } from "../../../types/storage/8/Elasticsearch";
 import ESWrapper from "./esWrapper";
-import QueryTranslator from "../commons/queryTranslator";
+import { QueryTranslator } from "../commons/queryTranslator";
 import { storeScopeEnum } from "../../../core/storage/storeScopeEnum";
 /**
  * @param {Kuzzle} kuzzle kuzzle instance

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

@@ -55,7 +55,7 @@ const bluebird_1 = __importDefault(require("bluebird"));
 const semver_1 = __importDefault(require("semver"));
 const debug_1 = __importDefault(require("../../../util/debug"));
 const esWrapper_1 = __importDefault(require("./esWrapper"));
-const queryTranslator_1 = __importDefault(require("../commons/queryTranslator"));
+const queryTranslator_1 = require("../commons/queryTranslator");
 const didYouMean_1 = __importDefault(require("../../../util/didYouMean"));
 const kerror = __importStar(require("../../../kerror"));
 const requestAssertions_1 = require("../../../util/requestAssertions");
@@ -106,7 +106,7 @@ class ES8 {
         this._client = null;
         this._esWrapper = null;
         this._esVersion = null;
-        this._translator = new queryTranslator_1.default();
+        this._translator = new queryTranslator_1.QueryTranslator();
         // Allowed root key of a search query
         this.searchBodyKeys = [
             "aggregations",

package/lib/service/storage/commons/queryTranslator.d.ts

@@ -0,0 +1,5 @@
+export declare class QueryTranslator {
+    translate(filters: any): any;
+    _translateOperator(operator: any, operands: any): any;
+    _translateClause(clause: any, content: any): any;
+}

package/lib/service/storage/commons/queryTranslator.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTranslator = void 0;
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,23 +21,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-"use strict";
-
-const kerror = require("../../../kerror");
-
+const kerror_1 = require("../../../kerror");
 class KeywordError extends Error {
-  constructor(type, name) {
-    super(
-      `The ${type} "${name}" of Koncorde DSL is not supported for search queries.`,
-    );
-
-    this.keyword = { name, type };
-  }
+    constructor(type, name) {
+        super(`The ${type} "${name}" of Koncorde DSL is not supported for search queries.`);
+        this.keyword = { name, type };
+    }
 }
-
 const KONCORDE_OPERATORS = ["and", "or", "not", "bool"];
-
 /**
  * Parse the Koncorde path to extract the path and the value
  * path have the form "path.to.field[json_value]"
@@ -43,177 +37,153 @@ const KONCORDE_OPERATORS = ["and", "or", "not", "bool"];
  * @returns
  */
 function parseKoncordePath(path) {
-  const firstBracket = path.indexOf("[");
-
-  if (firstBracket < 0) {
+    const firstBracket = path.indexOf("[");
+    if (firstBracket < 0) {
+        return {
+            path,
+        };
+    }
+    const lastBracket = path.lastIndexOf("]");
+    if (lastBracket < 0) {
+        throw (0, kerror_1.get)("services", "koncorde", "elastic_translation_error", `Invalid exists path "${path}": missing closing bracket`);
+    }
     return {
-      path,
+        path: path.slice(0, firstBracket),
+        value: JSON.parse(path.slice(firstBracket + 1, lastBracket)),
     };
-  }
-
-  const lastBracket = path.lastIndexOf("]");
-
-  if (lastBracket < 0) {
-    throw kerror.get(
-      "services",
-      "koncorde",
-      "elastic_translation_error",
-      `Invalid exists path "${path}": missing closing bracket`,
-    );
-  }
-
-  return {
-    path: path.slice(0, firstBracket),
-    value: JSON.parse(path.slice(firstBracket + 1, lastBracket)),
-  };
 }
-
 const KONCORDE_CLAUSES_TO_ES = {
-  equals: (content) => ({
-    term: {
-      ...content,
-    },
-  }),
-  exists: (field) => {
-    // Support old syntax { exists: { field: "path" } } and { exists: "path" }
-    const parsedInfo = parseKoncordePath(field.field || field);
-
-    // If we have a value, we need to use a range query to be sure that the value is the same
-    if (parsedInfo.value) {
-      return {
-        bool: {
-          filter: [
-            {
-              exists: {
-                field: parsedInfo.path,
-              },
-            },
-            {
-              range: {
-                [parsedInfo.path]: {
-                  gte: parsedInfo.value,
-                  lte: parsedInfo.value,
+    equals: (content) => ({
+        term: {
+            ...content,
+        },
+    }),
+    exists: (field) => {
+        // Support old syntax { exists: { field: "path" } } and { exists: "path" }
+        const parsedInfo = parseKoncordePath(field.field || field);
+        // If we have a value, we need to use a range query to be sure that the value is the same
+        if (parsedInfo.value) {
+            return {
+                bool: {
+                    filter: [
+                        {
+                            exists: {
+                                field: parsedInfo.path,
+                            },
+                        },
+                        {
+                            range: {
+                                [parsedInfo.path]: {
+                                    gte: parsedInfo.value,
+                                    lte: parsedInfo.value,
+                                },
+                            },
+                        },
+                    ],
                 },
-              },
+            };
+        }
+        return {
+            exists: {
+                field: parsedInfo.path,
             },
-          ],
-        },
-      };
-    }
-
-    return {
-      exists: {
-        field: parsedInfo.path,
-      },
-    };
-  },
-  geoBoundingBox: (content) => ({
-    geo_bounding_box: {
-      ...content,
-    },
-  }),
-  geoDistance: (content) => ({
-    geo_distance: {
-      ...content,
-    },
-  }),
-  geoDistanceRange: (content) => ({
-    geo_distance_range: {
-      ...content,
-    },
-  }),
-  geoPolygon: (content) => ({
-    geo_polygon: {
-      ...content,
-    },
-  }),
-  ids: (content) => ({
-    ids: {
-      ...content,
-    },
-  }),
-  in: (content) => ({
-    terms: {
-      ...content,
+        };
     },
-  }),
-  missing: (field) => ({
-    bool: {
-      must_not: [{ exists: { field } }],
-    },
-  }),
-  range: (content) => ({
-    range: {
-      ...content,
-    },
-  }),
+    geoBoundingBox: (content) => ({
+        geo_bounding_box: {
+            ...content,
+        },
+    }),
+    geoDistance: (content) => ({
+        geo_distance: {
+            ...content,
+        },
+    }),
+    geoDistanceRange: (content) => ({
+        geo_distance_range: {
+            ...content,
+        },
+    }),
+    geoPolygon: (content) => ({
+        geo_polygon: {
+            ...content,
+        },
+    }),
+    ids: (content) => ({
+        ids: {
+            ...content,
+        },
+    }),
+    in: (content) => ({
+        terms: {
+            ...content,
+        },
+    }),
+    missing: (field) => ({
+        bool: {
+            must_not: [{ exists: { field } }],
+        },
+    }),
+    range: (content) => ({
+        range: {
+            ...content,
+        },
+    }),
 };
-
 const KONCORDE_OPERATORS_TO_ES = {
-  and: (content) => ({
-    bool: {
-      filter: [...content],
-    },
-  }),
-  bool: undefined,
-  not: (content) => {
-    const [name, value] = Object.entries(content[0])[0];
-
-    return {
-      bool: {
-        must_not: [{ [name]: value }],
-      },
-    };
-  },
-  or: (content) => ({
-    bool: {
-      should: [...content],
+    and: (content) => ({
+        bool: {
+            filter: [...content],
+        },
+    }),
+    bool: undefined,
+    not: (content) => {
+        const [name, value] = Object.entries(content[0])[0];
+        return {
+            bool: {
+                must_not: [{ [name]: value }],
+            },
+        };
     },
-  }),
+    or: (content) => ({
+        bool: {
+            should: [...content],
+        },
+    }),
 };
-
 class QueryTranslator {
-  translate(filters) {
-    const [name, value] = Object.entries(filters)[0];
-
-    if (KONCORDE_OPERATORS.includes(name)) {
-      return this._translateOperator(name, value);
-    }
-
-    return this._translateClause(name, value);
-  }
-
-  _translateOperator(operator, operands) {
-    const converter = KONCORDE_OPERATORS_TO_ES[operator];
-
-    if (converter === undefined) {
-      throw new KeywordError("operator", operator);
+    translate(filters) {
+        const [name, value] = Object.entries(filters)[0];
+        if (KONCORDE_OPERATORS.includes(name)) {
+            return this._translateOperator(name, value);
+        }
+        return this._translateClause(name, value);
     }
-
-    const esOperands = [];
-
-    if (operator === "not") {
-      esOperands.push(this.translate(operands));
-    } else {
-      for (const operand of operands) {
-        esOperands.push(this.translate(operand));
-      }
+    _translateOperator(operator, operands) {
+        const converter = KONCORDE_OPERATORS_TO_ES[operator];
+        if (converter === undefined) {
+            throw new KeywordError("operator", operator);
+        }
+        const esOperands = [];
+        if (operator === "not") {
+            esOperands.push(this.translate(operands));
+        }
+        else {
+            for (const operand of operands) {
+                esOperands.push(this.translate(operand));
+            }
+        }
+        return converter(esOperands);
     }
-
-    return converter(esOperands);
-  }
-
-  _translateClause(clause, content) {
-    const converter = KONCORDE_CLAUSES_TO_ES[clause];
-
-    if (converter === undefined) {
-      return {
-        [clause]: content,
-      };
+    _translateClause(clause, content) {
+        const converter = KONCORDE_CLAUSES_TO_ES[clause];
+        if (converter === undefined) {
+            return {
+                [clause]: content,
+            };
+        }
+        return converter(content);
     }
-
-    return converter(content);
-  }
 }
-
-module.exports = QueryTranslator;
+exports.QueryTranslator = QueryTranslator;
+//# sourceMappingURL=queryTranslator.js.map

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.32.0-elasticsearch-8.1",
+  "version": "2.32.0",
   "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
   "bin": "bin/start-kuzzle-server",
   "scripts": {
     "build": "tsc",
     "clean": "touch index.ts && npm run build | grep TSFILE | cut -d' ' -f 2 | xargs rm",
-    "codecov": "codecov",
     "cucumber": "cucumber.js --fail-fast",
     "dev": "ergol docker/scripts/start-kuzzle-dev.ts -c ./config/ergol.config.json",
     "doc-error-codes": "node -r ts-node/register doc/build-error-codes",
@@ -45,7 +44,7 @@
     "json2yaml": "1.1.0",
     "jsonwebtoken": "9.0.2",
     "koncorde": "4.3.0",
-    "kuzzle-plugin-auth-passport-local": "6.4.0",
+    "kuzzle-plugin-auth-passport-local": "6.4.1",
     "kuzzle-plugin-logger": "3.0.3",
     "kuzzle-sdk": "^7.11.3",
     "kuzzle-vault": "2.0.4",
@@ -92,7 +91,6 @@
     "@types/lodash": "4.14.202",
     "async": "3.2.5",
     "chokidar": "3.5.3",
-    "codecov": "3.8.3",
     "cucumber": "6.0.5",
     "cz-conventional-changelog": "^3.3.0",
     "ergol": "1.0.2",