@webiny/api-elasticsearch 0.0.0-mt-1

package/plugins/operator/gte.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorGreaterThanOrEqualToPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorGreaterThanOrEqualToPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.greaterThanOrEqualTo.default");
+  }
+
+  getOperator() {
+    return "gte";
+  }
+
+  apply(query, params) {
+    const {
+      value,
+      basePath
+    } = params;
+    query.must.push({
+      range: {
+        [basePath]: {
+          gte: value
+        }
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorGreaterThanOrEqualToPlugin = ElasticsearchQueryBuilderOperatorGreaterThanOrEqualToPlugin;

package/plugins/operator/in.d.ts

@@ -0,0 +1,7 @@
+import { ElasticsearchQueryBuilderOperatorPlugin } from "../definition/ElasticsearchQueryBuilderOperatorPlugin";
+import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "../../types";
+export declare class ElasticsearchQueryBuilderOperatorInPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
+    name: string;
+    getOperator(): string;
+    apply(query: ElasticsearchBoolQueryConfig, params: ElasticsearchQueryBuilderArgsPlugin): void;
+}

package/plugins/operator/in.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorInPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorInPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.in.default");
+  }
+
+  getOperator() {
+    return "in";
+  }
+
+  apply(query, params) {
+    const {
+      value: values,
+      path,
+      basePath
+    } = params;
+    const isArray = Array.isArray(values);
+
+    if (isArray === false || values.length === 0) {
+      throw new Error(`You cannot filter field "${path}" with "in" operator and not send an array of values.`);
+    }
+
+    let useBasePath = false; // Only use ".keyword" if all of the provided values are strings.
+
+    for (const value of values) {
+      if (typeof value !== "string") {
+        useBasePath = true;
+        break;
+      }
+    }
+
+    query.must.push({
+      terms: {
+        [useBasePath ? basePath : path]: values
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorInPlugin = ElasticsearchQueryBuilderOperatorInPlugin;

package/plugins/operator/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./between";
+export * from "./contains";
+export * from "./equal";
+export * from "./gt";
+export * from "./gte";
+export * from "./andIn";
+export * from "./in";
+export * from "./lt";
+export * from "./lte";
+export * from "./not";
+export * from "./notBetween";
+export * from "./notContains";
+export * from "./notIn";

package/plugins/operator/index.js

@@ -0,0 +1,174 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _between = require("./between");
+
+Object.keys(_between).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _between[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _between[key];
+    }
+  });
+});
+
+var _contains = require("./contains");
+
+Object.keys(_contains).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _contains[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _contains[key];
+    }
+  });
+});
+
+var _equal = require("./equal");
+
+Object.keys(_equal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _equal[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _equal[key];
+    }
+  });
+});
+
+var _gt = require("./gt");
+
+Object.keys(_gt).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _gt[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gt[key];
+    }
+  });
+});
+
+var _gte = require("./gte");
+
+Object.keys(_gte).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _gte[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gte[key];
+    }
+  });
+});
+
+var _andIn = require("./andIn");
+
+Object.keys(_andIn).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _andIn[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _andIn[key];
+    }
+  });
+});
+
+var _in = require("./in");
+
+Object.keys(_in).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _in[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _in[key];
+    }
+  });
+});
+
+var _lt = require("./lt");
+
+Object.keys(_lt).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _lt[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _lt[key];
+    }
+  });
+});
+
+var _lte = require("./lte");
+
+Object.keys(_lte).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _lte[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _lte[key];
+    }
+  });
+});
+
+var _not = require("./not");
+
+Object.keys(_not).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _not[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _not[key];
+    }
+  });
+});
+
+var _notBetween = require("./notBetween");
+
+Object.keys(_notBetween).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _notBetween[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _notBetween[key];
+    }
+  });
+});
+
+var _notContains = require("./notContains");
+
+Object.keys(_notContains).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _notContains[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _notContains[key];
+    }
+  });
+});
+
+var _notIn = require("./notIn");
+
+Object.keys(_notIn).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _notIn[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _notIn[key];
+    }
+  });
+});

package/plugins/operator/lt.d.ts

@@ -0,0 +1,7 @@
+import { ElasticsearchQueryBuilderOperatorPlugin } from "../definition/ElasticsearchQueryBuilderOperatorPlugin";
+import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "../../types";
+export declare class ElasticsearchQueryBuilderOperatorLesserThanPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
+    name: string;
+    getOperator(): string;
+    apply(query: ElasticsearchBoolQueryConfig, params: ElasticsearchQueryBuilderArgsPlugin): void;
+}

package/plugins/operator/lt.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorLesserThanPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorLesserThanPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.lesserThan.default");
+  }
+
+  getOperator() {
+    return "lt";
+  }
+
+  apply(query, params) {
+    const {
+      value,
+      basePath
+    } = params;
+    query.must.push({
+      range: {
+        [basePath]: {
+          lt: value
+        }
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorLesserThanPlugin = ElasticsearchQueryBuilderOperatorLesserThanPlugin;

package/plugins/operator/lte.d.ts

@@ -0,0 +1,7 @@
+import { ElasticsearchQueryBuilderOperatorPlugin } from "../definition/ElasticsearchQueryBuilderOperatorPlugin";
+import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "../../types";
+export declare class ElasticsearchQueryBuilderOperatorLesserThanOrEqualToPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
+    name: string;
+    getOperator(): string;
+    apply(query: ElasticsearchBoolQueryConfig, params: ElasticsearchQueryBuilderArgsPlugin): void;
+}

package/plugins/operator/lte.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorLesserThanOrEqualToPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorLesserThanOrEqualToPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.lesserThanOrEqualTo.default");
+  }
+
+  getOperator() {
+    return "lte";
+  }
+
+  apply(query, params) {
+    const {
+      value,
+      basePath
+    } = params;
+    query.must.push({
+      range: {
+        [basePath]: {
+          lte: value
+        }
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorLesserThanOrEqualToPlugin = ElasticsearchQueryBuilderOperatorLesserThanOrEqualToPlugin;

package/plugins/operator/not.d.ts

@@ -0,0 +1,7 @@
+import { ElasticsearchQueryBuilderOperatorPlugin } from "../definition/ElasticsearchQueryBuilderOperatorPlugin";
+import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "../../types";
+export declare class ElasticsearchQueryBuilderOperatorNotPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
+    name: string;
+    getOperator(): string;
+    apply(query: ElasticsearchBoolQueryConfig, params: ElasticsearchQueryBuilderArgsPlugin): void;
+}

package/plugins/operator/not.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorNotPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorNotPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.not.default");
+  }
+
+  getOperator() {
+    return "not";
+  }
+
+  apply(query, params) {
+    const {
+      value,
+      path,
+      basePath
+    } = params;
+    const useBasePath = typeof value !== "string";
+    query.must_not.push({
+      term: {
+        [useBasePath ? basePath : path]: value
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorNotPlugin = ElasticsearchQueryBuilderOperatorNotPlugin;

package/plugins/operator/notBetween.d.ts

@@ -0,0 +1,7 @@
+import { ElasticsearchQueryBuilderOperatorPlugin } from "../definition/ElasticsearchQueryBuilderOperatorPlugin";
+import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "../../types";
+export declare class ElasticsearchQueryBuilderOperatorNotBetweenPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
+    name: string;
+    getOperator(): string;
+    apply(query: ElasticsearchBoolQueryConfig, params: ElasticsearchQueryBuilderArgsPlugin): void;
+}

package/plugins/operator/notBetween.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorNotBetweenPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorNotBetweenPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.notBetween.default");
+  }
+
+  getOperator() {
+    return "not_between";
+  }
+
+  apply(query, params) {
+    const {
+      value,
+      basePath
+    } = params;
+
+    if (Array.isArray(value) === false) {
+      throw new Error(`You cannot filter field path "${basePath}" with between query and not send an array of values.`);
+    } else if (value.length !== 2) {
+      throw new Error(`You must pass 2 values in the array for field path "${basePath}" filtering.`);
+    } // we take gte first because it should be a lesser value than lte, eg [5, 10]
+    // 6 >= gte && 6 <= lte === true which in this case it means that record will not match
+
+
+    const [gte, lte] = value;
+    query.must_not.push({
+      range: {
+        [basePath]: {
+          lte,
+          gte
+        }
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorNotBetweenPlugin = ElasticsearchQueryBuilderOperatorNotBetweenPlugin;

package/plugins/operator/notContains.d.ts

@@ -0,0 +1,7 @@
+import { ElasticsearchQueryBuilderOperatorPlugin } from "../definition/ElasticsearchQueryBuilderOperatorPlugin";
+import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "../../types";
+export declare class ElasticsearchQueryBuilderOperatorNotContainsPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
+    name: string;
+    getOperator(): string;
+    apply(query: ElasticsearchBoolQueryConfig, params: ElasticsearchQueryBuilderArgsPlugin): void;
+}

package/plugins/operator/notContains.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorNotContainsPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+var _normalize = require("../../normalize");
+
+class ElasticsearchQueryBuilderOperatorNotContainsPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.notContains.default");
+  }
+
+  getOperator() {
+    return "not_contains";
+  }
+
+  apply(query, params) {
+    const {
+      value,
+      basePath
+    } = params;
+    query.must_not.push({
+      query_string: {
+        allow_leading_wildcard: true,
+        fields: [basePath],
+        query: (0, _normalize.normalizeValue)(value),
+        default_operator: "and"
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorNotContainsPlugin = ElasticsearchQueryBuilderOperatorNotContainsPlugin;

package/plugins/operator/notIn.d.ts

@@ -0,0 +1,7 @@
+import { ElasticsearchQueryBuilderOperatorPlugin } from "../definition/ElasticsearchQueryBuilderOperatorPlugin";
+import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "../../types";
+export declare class ElasticsearchQueryBuilderOperatorNotInPlugin extends ElasticsearchQueryBuilderOperatorPlugin {
+    name: string;
+    getOperator(): string;
+    apply(query: ElasticsearchBoolQueryConfig, params: ElasticsearchQueryBuilderArgsPlugin): void;
+}

package/plugins/operator/notIn.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorNotInPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorNotInPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.notIn.default");
+  }
+
+  getOperator() {
+    return "not_in";
+  }
+
+  apply(query, params) {
+    const {
+      value: values,
+      path,
+      basePath
+    } = params;
+    const isArray = Array.isArray(values);
+
+    if (isArray === false || values.length === 0) {
+      throw new Error(`You cannot filter field path "${basePath}" with not_in and not send an array of values.`);
+    }
+
+    const useBasePath = values.some(value => typeof value !== "string");
+    query.must_not.push({
+      terms: {
+        [useBasePath ? basePath : path]: values
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorNotInPlugin = ElasticsearchQueryBuilderOperatorNotInPlugin;

package/sort.d.ts

@@ -0,0 +1,12 @@
+import { SortType, SortOrder } from "./types";
+import { ElasticsearchFieldPlugin } from "./plugins/definition/ElasticsearchFieldPlugin";
+export interface Params {
+    sort: string[];
+    defaults?: {
+        field?: string;
+        order?: SortOrder;
+        unmappedType?: string;
+    };
+    fieldPlugins: Record<string, ElasticsearchFieldPlugin>;
+}
+export declare const createSort: (params: Params) => SortType;