@webiny/api-elasticsearch 0.0.0-mt-1

package/plugins/definition/ElasticsearchFieldPlugin.d.ts

@@ -0,0 +1,87 @@
+import { Plugin } from "@webiny/plugins";
+import { FieldSortOptions, SortOrder } from "elastic-ts";
+export declare type UnmappedTypes = "date" | "long" | string;
+export interface ToSearchValueParams {
+    /**
+     * The value to transform.
+     */
+    value: any;
+    /**
+     * When using toSearchValue() in our code we send a field.getPath() value here.
+     */
+    path: string;
+    /**
+     * When using toSearchValue() in our code we send a field.getBasePath() value here.
+     */
+    basePath: string;
+}
+export interface Params {
+    /**
+     * Which field is this plugin for.
+     */
+    field: string;
+    /**
+     * Some specific path of a field?
+     * Example: createdBy is createdBy.id
+     */
+    path?: string;
+    /**
+     * Add a .keyword at the end of the field path?
+     */
+    keyword?: boolean;
+    /**
+     * Is the field of a specific type, but possibly not mapped?
+     * Happens when inserting a date in string format.
+     * You need to cast it as date when running the search/sort to work correctly.
+     */
+    unmappedType?: UnmappedTypes;
+    /**
+     * Is the field sortable?
+     */
+    sortable?: boolean;
+    /**
+     * Is the field searchable?
+     */
+    searchable?: boolean;
+    /**
+     * Used to transform the input value for the search.
+     */
+    toSearchValue?: (params: ToSearchValueParams) => any;
+}
+export declare abstract class ElasticsearchFieldPlugin extends Plugin {
+    static readonly type: string;
+    static readonly ALL: string;
+    private readonly _field;
+    private readonly _path;
+    private readonly _keyword;
+    private readonly _unmappedType;
+    private readonly _sortable;
+    private readonly _searchable;
+    get field(): string;
+    get path(): string;
+    get keyword(): boolean;
+    get unmappedType(): string | undefined;
+    get sortable(): boolean;
+    get searchable(): boolean;
+    constructor(params: Params);
+    /**
+     * The default sort options. Extend in your own plugin if you want to add more options.
+     */
+    getSortOptions(order: SortOrder): FieldSortOptions;
+    /**
+     * The default path generator. Extend in your own plugin if you want to add more options.
+     * Field parameter is here because there is a possibility that this is the ALL field plugin, so we need to know which field are we working on.
+     */
+    getPath(field: string): string;
+    /**
+     * @see getPath
+     *
+     * This is the default base path generator. Basically it replaces ALL with given field name.
+     */
+    getBasePath(field: string): string;
+    /**
+     * The default transformer. Just returns the value by default.
+     * Override to implement what ever is required.
+     */
+    toSearchValue(params: ToSearchValueParams): any;
+}

package/plugins/definition/ElasticsearchFieldPlugin.js

@@ -0,0 +1,128 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchFieldPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const keywordLessUnmappedType = ["date", "long"];
+
+const unmappedTypeHasKeyword = type => {
+  if (keywordLessUnmappedType.includes(type)) {
+    return false;
+  }
+
+  return true;
+};
+
+class ElasticsearchFieldPlugin extends _plugins.Plugin {
+  get field() {
+    return this._field;
+  }
+
+  get path() {
+    return this._path;
+  }
+
+  get keyword() {
+    return this._keyword;
+  }
+
+  get unmappedType() {
+    return this._unmappedType;
+  }
+
+  get sortable() {
+    return this._sortable;
+  }
+
+  get searchable() {
+    return this._searchable;
+  }
+
+  constructor(params) {
+    super();
+    (0, _defineProperty2.default)(this, "_field", void 0);
+    (0, _defineProperty2.default)(this, "_path", void 0);
+    (0, _defineProperty2.default)(this, "_keyword", void 0);
+    (0, _defineProperty2.default)(this, "_unmappedType", void 0);
+    (0, _defineProperty2.default)(this, "_sortable", void 0);
+    (0, _defineProperty2.default)(this, "_searchable", void 0);
+    this._field = params.field;
+    this._path = params.path || params.field;
+    this._keyword = params.keyword === undefined ? true : params.keyword;
+    this._unmappedType = params.unmappedType;
+
+    if (unmappedTypeHasKeyword(params.unmappedType) === false) {
+      this._keyword = false;
+    }
+
+    this._sortable = params.sortable === undefined ? true : params.sortable;
+    this._searchable = params.searchable === undefined ? true : params.searchable;
+  }
+  /**
+   * The default sort options. Extend in your own plugin if you want to add more options.
+   */
+
+
+  getSortOptions(order) {
+    const options = {
+      order
+    };
+
+    if (!this._unmappedType) {
+      return options;
+    }
+
+    return _objectSpread(_objectSpread({}, options), {}, {
+      unmapped_type: this._unmappedType
+    });
+  }
+  /**
+   * The default path generator. Extend in your own plugin if you want to add more options.
+   * Field parameter is here because there is a possibility that this is the ALL field plugin, so we need to know which field are we working on.
+   */
+
+
+  getPath(field) {
+    return `${this.getBasePath(field)}${this._keyword ? ".keyword" : ""}`;
+  }
+  /**
+   * @see getPath
+   *
+   * This is the default base path generator. Basically it replaces ALL with given field name.
+   */
+
+
+  getBasePath(field) {
+    if (this._path === this.constructor.ALL) {
+      return field;
+    }
+
+    return this._path;
+  }
+  /**
+   * The default transformer. Just returns the value by default.
+   * Override to implement what ever is required.
+   */
+
+
+  toSearchValue(params) {
+    return params.value;
+  }
+
+}
+
+exports.ElasticsearchFieldPlugin = ElasticsearchFieldPlugin;
+(0, _defineProperty2.default)(ElasticsearchFieldPlugin, "type", "elasticsearch.fieldDefinition");
+(0, _defineProperty2.default)(ElasticsearchFieldPlugin, "ALL", "*");

package/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin.d.ts

@@ -0,0 +1,10 @@
+import { Plugin } from "@webiny/plugins";
+import { ElasticsearchBoolQueryConfig, ElasticsearchQueryBuilderArgsPlugin } from "../../types";
+/**
+ * Built-in operators name ends with .default because user can override the operator, just write a name without the .default keyword.
+ */
+export declare abstract class ElasticsearchQueryBuilderOperatorPlugin extends Plugin {
+    static readonly type = "elasticsearch.queryBuilder.operator";
+    abstract getOperator(): string;
+    abstract apply(query: ElasticsearchBoolQueryConfig, params: ElasticsearchQueryBuilderArgsPlugin): void;
+}

package/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+/**
+ * Built-in operators name ends with .default because user can override the operator, just write a name without the .default keyword.
+ */
+class ElasticsearchQueryBuilderOperatorPlugin extends _plugins.Plugin {}
+
+exports.ElasticsearchQueryBuilderOperatorPlugin = ElasticsearchQueryBuilderOperatorPlugin;
+(0, _defineProperty2.default)(ElasticsearchQueryBuilderOperatorPlugin, "type", "elasticsearch.queryBuilder.operator");

package/plugins/definition/ElasticsearchQueryModifierPlugin.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from "@webiny/plugins";
+import { ElasticsearchBoolQueryConfig } from "../../types";
+export interface ModifyQueryParams {
+    query: ElasticsearchBoolQueryConfig;
+    where: Record<string, any>;
+}
+export interface ModifyQueryCallable<T extends ModifyQueryParams> {
+    (params: T): void;
+}
+export declare abstract class ElasticsearchQueryModifierPlugin<T extends ModifyQueryParams = ModifyQueryParams> extends Plugin {
+    private readonly callable?;
+    constructor(callable?: ModifyQueryCallable<T>);
+    modifyQuery(params: T): void;
+}

package/plugins/definition/ElasticsearchQueryModifierPlugin.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryModifierPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _plugins = require("@webiny/plugins");
+
+class ElasticsearchQueryModifierPlugin extends _plugins.Plugin {
+  constructor(callable) {
+    super();
+    (0, _defineProperty2.default)(this, "callable", void 0);
+    this.callable = callable;
+  }
+
+  modifyQuery(params) {
+    if (typeof this.callable !== "function") {
+      throw new _error.default(`Missing modification for the query.`, "QUERY_MODIFICATION_MISSING", {
+        params
+      });
+    }
+
+    this.callable(params);
+  }
+
+}
+
+exports.ElasticsearchQueryModifierPlugin = ElasticsearchQueryModifierPlugin;

package/plugins/definition/ElasticsearchSortModifierPlugin.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from "@webiny/plugins";
+import { Sort } from "elastic-ts";
+export interface ModifySortParams {
+    sort: Sort;
+}
+export interface ModifySortCallable<T extends ModifySortParams> {
+    (params: T): void;
+}
+export declare abstract class ElasticsearchSortModifierPlugin<T extends ModifySortParams = ModifySortParams> extends Plugin {
+    private readonly callable?;
+    constructor(callable?: ModifySortCallable<T>);
+    modifySort(params: T): void;
+}

package/plugins/definition/ElasticsearchSortModifierPlugin.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchSortModifierPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _plugins = require("@webiny/plugins");
+
+class ElasticsearchSortModifierPlugin extends _plugins.Plugin {
+  constructor(callable) {
+    super();
+    (0, _defineProperty2.default)(this, "callable", void 0);
+    this.callable = callable;
+  }
+
+  modifySort(params) {
+    if (typeof this.callable !== "function") {
+      throw new _error.default(`Missing modification for the sort.`, "SORT_MODIFICATION_MISSING", {
+        params
+      });
+    }
+
+    this.callable(params);
+  }
+
+}
+
+exports.ElasticsearchSortModifierPlugin = ElasticsearchSortModifierPlugin;

package/plugins/operator/andIn.d.ts

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

package/plugins/operator/andIn.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorAndInPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorAndInPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.andIn.default");
+  }
+
+  getOperator() {
+    return "and_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;
+      }
+    }
+
+    for (const value of values) {
+      query.must.push({
+        term: {
+          [useBasePath ? basePath : path]: value
+        }
+      });
+    }
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorAndInPlugin = ElasticsearchQueryBuilderOperatorAndInPlugin;

package/plugins/operator/between.d.ts

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

package/plugins/operator/between.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorBetweenPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorBetweenPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.between.default");
+  }
+
+  getOperator() {
+    return "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
+
+
+    const [gte, lte] = value;
+    query.must.push({
+      range: {
+        [basePath]: {
+          lte,
+          gte
+        }
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorBetweenPlugin = ElasticsearchQueryBuilderOperatorBetweenPlugin;

package/plugins/operator/contains.d.ts

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

package/plugins/operator/contains.js

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

package/plugins/operator/equal.d.ts

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

package/plugins/operator/equal.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ElasticsearchQueryBuilderOperatorEqualPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("../definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+class ElasticsearchQueryBuilderOperatorEqualPlugin extends _ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "elasticsearch.queryBuilder.operator.equal.default");
+  }
+
+  getOperator() {
+    return "eq";
+  }
+
+  apply(query, params) {
+    const {
+      value,
+      path,
+      basePath
+    } = params;
+    /**
+     * In case we are searching for a string, use regular path.
+     * Otherwise use base path
+     */
+
+    const useBasePath = typeof value !== "string";
+    query.must.push({
+      term: {
+        [useBasePath ? basePath : path]: value
+      }
+    });
+  }
+
+}
+
+exports.ElasticsearchQueryBuilderOperatorEqualPlugin = ElasticsearchQueryBuilderOperatorEqualPlugin;

package/plugins/operator/gt.d.ts

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

package/plugins/operator/gt.js

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

package/plugins/operator/gte.d.ts

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