kuzzle 2.31.0-elasticsearch-8.2 → 2.32.0-beta.1

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/lib/types/EventHandler.d.ts

@@ -14,10 +14,30 @@ export type EventDefinition = {
      */
     args: any[];
 };
+/**
+ * Describe an ask event with it's name and the payload and result types
+ */
+export type AskEventDefinition = {
+    /**
+     * Name of the event
+     *
+     * @example
+     * "core:document:create"
+     */
+    name: string;
+    /**
+     * Payload of the event
+     */
+    payload: any;
+    /**
+     * Result of the event
+     */
+    result: any;
+};
 /**
  * Handler for hook events
  */
-export type HookEventHandler<TEventDefinition extends EventDefinition = EventDefinition> = (...args: TEventDefinition["args"]) => void;
+export type HookEventHandler<TEventDefinition extends EventDefinition = EventDefinition> = (...args: TEventDefinition["args"]) => Promise<void> | void;
 /**
  * Handler for pipe event.
  *
@@ -28,6 +48,14 @@ export type PipeEventHandler<TEventDefinition extends EventDefinition = EventDef
  * Handler for cluster event.
  */
 export type ClusterEventHandler<TEventDefinition extends EventDefinition = EventDefinition> = (...args: TEventDefinition["args"]) => any;
+/**
+ * Handler for ask event.
+ */
+export type AskEventHandler<TAskEventDefinition extends AskEventDefinition = AskEventDefinition> = (...args: [payload?: TAskEventDefinition["payload"], ...rest: any[]]) => Promise<TAskEventDefinition["result"]> | TAskEventDefinition["result"];
+/**
+ * Handler for call event.
+ */
+export type CallEventHandler<TAskEventDefinition extends AskEventDefinition = AskEventDefinition> = (...args: [payload?: TAskEventDefinition["payload"], ...rest: any[]]) => TAskEventDefinition["result"];
 /**
  * @deprecated Use HookEventHandler, PipeEventHandler or ClusterEventHandler
  */

package/lib/types/config/KuzzleConfiguration.d.ts

@@ -1,4 +1,4 @@
-import { ServerConfiguration, ServicesConfiguration, SecurityConfiguration, HttpConfiguration, PluginsConfiguration, LimitsConfiguration, DumpConfiguration } from "../index";
+import { DumpConfiguration, HttpConfiguration, LimitsConfiguration, PluginsConfiguration, SecurityConfiguration, ServerConfiguration, ServicesConfiguration } from "../index";
 export interface IKuzzleConfiguration {
     realtime: {
         /**
@@ -121,6 +121,7 @@ export interface IKuzzleConfiguration {
     };
     internal: {
         hash: any;
+        notifiableProtocols: string[];
     };
     validation: Record<string, unknown>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.31.0-elasticsearch-8.2",
+  "version": "2.32.0-beta.1",
   "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": {
@@ -47,7 +47,7 @@
     "koncorde": "4.3.0",
     "kuzzle-plugin-auth-passport-local": "6.4.0",
     "kuzzle-plugin-logger": "3.0.3",
-    "kuzzle-sdk": "7.11.1",
+    "kuzzle-sdk": "^7.11.3",
     "kuzzle-vault": "2.0.4",
     "lodash": "4.17.21",
     "long": "5.2.3",
@@ -86,6 +86,7 @@
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/release-notes-generator": "^11.0.4",
     "@types/bluebird": "^3.5.42",
+    "@types/cookie": "^0.6.0",
     "@types/jest": "29.5.10",
     "@types/js-yaml": "4.0.9",
     "@types/lodash": "4.14.202",