@webiny/api-elasticsearch 0.0.0-mt-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @webiny/api-elasticsearch

package/client.d.ts

@@ -0,0 +1,5 @@
+import { Client, ClientOptions } from "@elastic/elasticsearch";
+export interface ElasticsearchClientOptions extends ClientOptions {
+    endpoint?: string;
+}
+export declare const createElasticsearchClient: (options: ElasticsearchClientOptions) => Client;

package/client.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElasticsearchClient = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _elasticsearch = require("@elastic/elasticsearch");
+
+var _awsSdk = _interopRequireDefault(require("aws-sdk"));
+
+var _awsElasticsearchConnector = _interopRequireDefault(require("aws-elasticsearch-connector"));
+
+const _excluded = ["endpoint", "node"];
+
+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 createElasticsearchClient = options => {
+  const {
+    endpoint,
+    node
+  } = options,
+        rest = (0, _objectWithoutProperties2.default)(options, _excluded);
+
+  const clientOptions = _objectSpread({
+    node: endpoint || node
+  }, rest);
+
+  if (!clientOptions.auth) {
+    /**
+     * If no `auth` configuration is present, we setup AWS connector.
+     */
+    Object.assign(clientOptions, (0, _awsElasticsearchConnector.default)(_awsSdk.default.config));
+  }
+
+  return new _elasticsearch.Client(clientOptions);
+};
+
+exports.createElasticsearchClient = createElasticsearchClient;

package/compression.d.ts

@@ -0,0 +1,6 @@
+import { PluginsContainer } from "@webiny/plugins";
+/**
+ * Method to compress the elasticsearch data that is going to be stored into the DynamoDB table that is meant for elasticsearch.
+ */
+export declare const compress: (pluginsContainer: PluginsContainer, data: Record<string, any>) => Promise<Record<string, any>>;
+export declare const decompress: (pluginsContainer: PluginsContainer, data: Record<string, any>) => Promise<Record<string, any>>;

package/compression.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decompress = exports.compress = void 0;
+
+var _CompressionPlugin = require("./plugins/definition/CompressionPlugin");
+
+/**
+ * Get the compression plugins, in reverse order, because we want to use the last one added - first.
+ */
+const getCompressionPlugins = plugins => {
+  return plugins.byType(_CompressionPlugin.CompressionPlugin.type).reverse();
+};
+/**
+ * Method to compress the elasticsearch data that is going to be stored into the DynamoDB table that is meant for elasticsearch.
+ */
+
+
+const compress = async (pluginsContainer, data) => {
+  const plugins = getCompressionPlugins(pluginsContainer);
+
+  if (plugins.length === 0) {
+    console.log("No compression plugins");
+    return data;
+  }
+
+  for (const plugin of plugins) {
+    if (plugin.canCompress(data) === false) {
+      continue;
+    }
+
+    return await plugin.compress(data);
+  }
+  /**
+   * Possibly no plugins that can compress, just return the data.
+   */
+
+
+  return data;
+};
+
+exports.compress = compress;
+
+const decompress = async (pluginsContainer, data) => {
+  const plugins = getCompressionPlugins(pluginsContainer);
+
+  if (plugins.length === 0) {
+    return data;
+  }
+
+  for (const plugin of plugins) {
+    if (plugin.canDecompress(data) === false) {
+      continue;
+    }
+
+    return await plugin.decompress(data);
+  }
+  /**
+   * Possibly no plugins that can decompress, just return the data.
+   */
+
+
+  return data;
+};
+
+exports.decompress = decompress;

package/cursors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Encode a received cursor value into something that can be passed on to the user.
+ */
+export declare const encodeCursor: (cursor?: string | string[]) => string | undefined;
+/**
+ * Decode a received value into a Elasticsearch cursor.
+ * If no value is received or is not decodable, return undefined.
+ */
+export declare const decodeCursor: (cursor?: string) => string[] | string | undefined;

package/cursors.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encodeCursor = exports.decodeCursor = void 0;
+
+/**
+ * Encode a received cursor value into something that can be passed on to the user.
+ */
+const encodeCursor = cursor => {
+  if (!cursor) {
+    return undefined;
+  }
+
+  cursor = Array.isArray(cursor) ? cursor.map(encodeURIComponent) : encodeURIComponent(cursor);
+
+  try {
+    return Buffer.from(JSON.stringify(cursor)).toString("base64");
+  } catch (ex) {
+    console.error(ex.message);
+  }
+
+  return undefined;
+};
+/**
+ * Decode a received value into a Elasticsearch cursor.
+ * If no value is received or is not decodable, return undefined.
+ */
+
+
+exports.encodeCursor = encodeCursor;
+
+const decodeCursor = cursor => {
+  if (!cursor) {
+    return undefined;
+  }
+
+  try {
+    const value = JSON.parse(Buffer.from(cursor, "base64").toString("ascii"));
+    return Array.isArray(value) ? value.map(decodeURIComponent) : decodeURIComponent(value);
+  } catch (ex) {
+    console.error(ex.message);
+  }
+
+  return undefined;
+};
+
+exports.decodeCursor = decodeCursor;

package/index.d.ts

@@ -0,0 +1,9 @@
+import { ElasticsearchContext } from "./types";
+import { ContextPlugin } from "@webiny/handler/plugins/ContextPlugin";
+import { ElasticsearchClientOptions } from "./client";
+import { Client } from "@elastic/elasticsearch";
+declare const _default: (params: ElasticsearchClientOptions | Client) => ContextPlugin<ElasticsearchContext>;
+/**
+ * We must accept either Elasticsearch client or options that create the client.
+ */
+export default _default;

package/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _client = require("./client");
+
+var _operators = require("./operators");
+
+var _elasticsearch = require("@elastic/elasticsearch");
+
+/**
+ * We must accept either Elasticsearch client or options that create the client.
+ */
+var _default = params => {
+  return new _ContextPlugin.ContextPlugin(context => {
+    if (context.elasticsearch) {
+      throw new _error.default("Elasticsearch client is already initialized, no need to define it again. Check your code for duplicate initializations.", "ELASTICSEARCH_ALREADY_INITIALIZED");
+    }
+    /**
+     * Initialize the Elasticsearch client.
+     */
+
+
+    context.elasticsearch = params instanceof _elasticsearch.Client ? params : (0, _client.createElasticsearchClient)(params);
+    context.plugins.register((0, _operators.getElasticsearchOperators)());
+  });
+};
+
+exports.default = _default;

package/limit.d.ts

@@ -0,0 +1 @@
+export declare const createLimit: (limit?: number, defaultValue?: number) => number;

package/limit.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLimit = void 0;
+
+/**
+ * This is the max limit of the Elasticsearch.
+ * Change here if it changes (and if it is necessary).
+ */
+const ES_LIMIT_MAX = 10000;
+/**
+ * Our system default limit.
+ */
+
+const ES_LIMIT_DEFAULT = 50;
+
+const createLimit = (limit, defaultValue = ES_LIMIT_DEFAULT) => {
+  /**
+   * Limit can possibly be null/undefined or less than 1.
+   * In that case return the defaults.
+   */
+  if (!limit || limit < 1) {
+    return defaultValue;
+  }
+  /**
+   * Users input limit cannot be greater than the Elasticsearch one.
+   * Elasticsearch query breaks because of that.
+   */
+
+
+  if (limit < ES_LIMIT_MAX) {
+    return limit;
+  }
+  /**
+   * Always reduce by 1 because we check if there are more items by adding 1 to the limit
+   * and then remove that last one loaded.
+   */
+
+
+  return ES_LIMIT_MAX - 1;
+};
+
+exports.createLimit = createLimit;

package/normalize.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Before performing the query, we need to escape all special characters.
+ * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters
+ */
+export declare const normalizeValue: (value: string) => string;

package/normalize.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeValue = void 0;
+
+/**
+ * Before performing the query, we need to escape all special characters.
+ * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters
+ */
+const RESERVED_CHARACTERS = {
+  // These characters need to be escaped with backslash ("\").
+  escape: ["\\\\", "\\/", "\\+", "\\-", "\\=", "\\&\\&", "\\|\\|", "\\!", "\\(", "\\)", "\\{", "\\}", "\\[", "\\]", "\\^", '\\"', "\\~", "\\*", "\\?", "\\:", "\\>", "\\<"]
+};
+
+const normalizeValue = value => {
+  let result = value;
+
+  for (const character of RESERVED_CHARACTERS.escape) {
+    result = result.replace(new RegExp(`${character}`, "g"), ` `);
+  }
+
+  return result ? `*${result}*` : "";
+};
+
+exports.normalizeValue = normalizeValue;

package/operators.d.ts

@@ -0,0 +1,18 @@
+import { ElasticsearchQueryBuilderOperatorBetweenPlugin } from "./plugins/operator/between";
+import { ElasticsearchQueryBuilderOperatorNotBetweenPlugin } from "./plugins/operator/notBetween";
+import { ElasticsearchQueryBuilderOperatorContainsPlugin } from "./plugins/operator/contains";
+import { ElasticsearchQueryBuilderOperatorNotContainsPlugin } from "./plugins/operator/notContains";
+import { ElasticsearchQueryBuilderOperatorEqualPlugin } from "./plugins/operator/equal";
+import { ElasticsearchQueryBuilderOperatorNotPlugin } from "./plugins/operator/not";
+import { ElasticsearchQueryBuilderOperatorGreaterThanPlugin } from "./plugins/operator/gt";
+import { ElasticsearchQueryBuilderOperatorGreaterThanOrEqualToPlugin } from "./plugins/operator/gte";
+import { ElasticsearchQueryBuilderOperatorLesserThanPlugin } from "./plugins/operator/lt";
+import { ElasticsearchQueryBuilderOperatorLesserThanOrEqualToPlugin } from "./plugins/operator/lte";
+import { ElasticsearchQueryBuilderOperatorInPlugin } from "./plugins/operator/in";
+import { ElasticsearchQueryBuilderOperatorAndInPlugin } from "./plugins/operator/andIn";
+import { ElasticsearchQueryBuilderOperatorNotInPlugin } from "./plugins/operator/notIn";
+/**
+ * We export as a function because there might be something to be sent to the operators at some point.
+ * This way, we make it easier to upgrade.
+ */
+export declare const getElasticsearchOperators: () => (ElasticsearchQueryBuilderOperatorBetweenPlugin | ElasticsearchQueryBuilderOperatorNotBetweenPlugin | ElasticsearchQueryBuilderOperatorContainsPlugin | ElasticsearchQueryBuilderOperatorNotContainsPlugin | ElasticsearchQueryBuilderOperatorEqualPlugin | ElasticsearchQueryBuilderOperatorNotPlugin | ElasticsearchQueryBuilderOperatorGreaterThanPlugin | ElasticsearchQueryBuilderOperatorGreaterThanOrEqualToPlugin | ElasticsearchQueryBuilderOperatorLesserThanPlugin | ElasticsearchQueryBuilderOperatorLesserThanOrEqualToPlugin | ElasticsearchQueryBuilderOperatorInPlugin | ElasticsearchQueryBuilderOperatorAndInPlugin | ElasticsearchQueryBuilderOperatorNotInPlugin)[];

package/operators.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getElasticsearchOperators = void 0;
+
+var _between = require("./plugins/operator/between");
+
+var _notBetween = require("./plugins/operator/notBetween");
+
+var _contains = require("./plugins/operator/contains");
+
+var _notContains = require("./plugins/operator/notContains");
+
+var _equal = require("./plugins/operator/equal");
+
+var _not = require("./plugins/operator/not");
+
+var _gt = require("./plugins/operator/gt");
+
+var _gte = require("./plugins/operator/gte");
+
+var _lt = require("./plugins/operator/lt");
+
+var _lte = require("./plugins/operator/lte");
+
+var _in = require("./plugins/operator/in");
+
+var _andIn = require("./plugins/operator/andIn");
+
+var _notIn = require("./plugins/operator/notIn");
+
+const operators = [new _between.ElasticsearchQueryBuilderOperatorBetweenPlugin(), new _notBetween.ElasticsearchQueryBuilderOperatorNotBetweenPlugin(), new _contains.ElasticsearchQueryBuilderOperatorContainsPlugin(), new _notContains.ElasticsearchQueryBuilderOperatorNotContainsPlugin(), new _equal.ElasticsearchQueryBuilderOperatorEqualPlugin(), new _not.ElasticsearchQueryBuilderOperatorNotPlugin(), new _gt.ElasticsearchQueryBuilderOperatorGreaterThanPlugin(), new _gte.ElasticsearchQueryBuilderOperatorGreaterThanOrEqualToPlugin(), new _lt.ElasticsearchQueryBuilderOperatorLesserThanPlugin(), new _lte.ElasticsearchQueryBuilderOperatorLesserThanOrEqualToPlugin(), new _in.ElasticsearchQueryBuilderOperatorInPlugin(), new _andIn.ElasticsearchQueryBuilderOperatorAndInPlugin(), new _notIn.ElasticsearchQueryBuilderOperatorNotInPlugin()];
+/**
+ * We export as a function because there might be something to be sent to the operators at some point.
+ * This way, we make it easier to upgrade.
+ */
+
+const getElasticsearchOperators = () => operators;
+
+exports.getElasticsearchOperators = getElasticsearchOperators;

package/package.json

@@ -0,0 +1,49 @@
+{
+	"name": "@webiny/api-elasticsearch",
+	"version": "0.0.0-mt-1",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-elasticsearch"
+	},
+	"description": "A set of plugins to work with Elasticsearch.",
+	"contributors": [
+		"Pavel Denisjuk <pavel@webiny.com>"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"@elastic/elasticsearch": "7.12.0",
+		"@webiny/error": "0.0.0-mt-1",
+		"@webiny/handler": "0.0.0-mt-1",
+		"@webiny/plugins": "0.0.0-mt-1",
+		"@webiny/utils": "0.0.0-mt-1",
+		"aws-elasticsearch-connector": "9.0.3",
+		"aws-sdk": "2.1026.0",
+		"elastic-ts": "0.7.0"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@webiny/cli": "^0.0.0-mt-1",
+		"@webiny/project-utils": "^0.0.0-mt-1",
+		"rimraf": "^3.0.2",
+		"ttypescript": "^1.5.12",
+		"typescript": "^4.1.3"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"scripts": {
+		"build": "yarn webiny run build",
+		"watch": "yarn webiny run watch"
+	},
+	"adio": {
+		"ignore": {
+			"src": [
+				"aws-sdk"
+			]
+		}
+	},
+	"gitHead": "37736d8456a6ecb342a6c3645060bd9a3f2d4bb0"
+}

package/plugins/GzipCompression.d.ts

@@ -0,0 +1,19 @@
+import { CompressionPlugin } from "./definition/CompressionPlugin";
+export interface CompressedData {
+    compression: string;
+    value: string;
+}
+interface OriginalData {
+    [key: string]: any;
+}
+declare class GzipCompression extends CompressionPlugin {
+    canCompress(data: any): boolean;
+    compress(data: any): Promise<{
+        compression: string;
+        value: string;
+    }>;
+    canDecompress(data: CompressedData | Record<string, any>): boolean;
+    decompress(data: CompressedData): Promise<OriginalData | null>;
+}
+declare const _default: () => GzipCompression;
+export default _default;

package/plugins/GzipCompression.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _CompressionPlugin = require("./definition/CompressionPlugin");
+
+var _gzip = require("@webiny/utils/compression/gzip");
+
+const GZIP = "gzip";
+const TO_STORAGE_ENCODING = "base64";
+const FROM_STORAGE_ENCODING = "utf8";
+
+const convertToBuffer = value => {
+  if (typeof value === "string") {
+    return Buffer.from(value, TO_STORAGE_ENCODING);
+  }
+
+  return value;
+};
+
+class GzipCompression extends _CompressionPlugin.CompressionPlugin {
+  canCompress(data) {
+    /**
+     * If already compressed, skip this.
+     */
+    if (data.compression) {
+      if (data.compression !== "GZIP") {
+        console.log(`Data is already compressed with "${data.compression}".`);
+      }
+
+      return false;
+    }
+
+    return true;
+  }
+
+  async compress(data) {
+    const value = await (0, _gzip.compress)(JSON.stringify(data));
+    return {
+      compression: GZIP,
+      value: value.toString(TO_STORAGE_ENCODING)
+    };
+  }
+
+  canDecompress(data) {
+    if (!data || !data.compression) {
+      return false;
+    } else if (data.compression !== GZIP) {
+      console.log(`Could not decompress given data since its compression is not "${GZIP}". It is "${data.compression}".`);
+      return false;
+    }
+
+    return true;
+  }
+
+  async decompress(data) {
+    try {
+      const buf = await (0, _gzip.decompress)(convertToBuffer(data.value));
+      const value = buf.toString(FROM_STORAGE_ENCODING);
+      return JSON.parse(value);
+    } catch (ex) {
+      return null;
+    }
+  }
+
+}
+
+var _default = () => {
+  return new GzipCompression();
+};
+
+exports.default = _default;

package/plugins/definition/CompressionPlugin.d.ts

@@ -0,0 +1,20 @@
+import { Plugin } from "@webiny/plugins";
+export declare abstract class CompressionPlugin extends Plugin {
+    static readonly type = "elasticsearch.compression";
+    /**
+     * Check if data can be compressed.
+     */
+    abstract canCompress(data: any): boolean;
+    /**
+     * Pass the data to get the compressed one back.
+     */
+    abstract compress(data: any): Promise<any>;
+    /**
+     * Check if data can be decompressed.
+     */
+    abstract canDecompress(data: any): boolean;
+    /**
+     * Passed the compressed data to get the original data back.
+     */
+    abstract decompress(data: any): Promise<any>;
+}

package/plugins/definition/CompressionPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CompressionPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class CompressionPlugin extends _plugins.Plugin {}
+
+exports.CompressionPlugin = CompressionPlugin;
+(0, _defineProperty2.default)(CompressionPlugin, "type", "elasticsearch.compression");

package/plugins/definition/ElasticsearchBodyModifierPlugin.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from "@webiny/plugins";
+import { SearchBody } from "elastic-ts";
+export interface ModifyBodyParams {
+    body: SearchBody;
+}
+export interface ModifyBodyCallable<T extends ModifyBodyParams> {
+    (params: T): void;
+}
+export declare abstract class ElasticsearchBodyModifierPlugin<T extends ModifyBodyParams = ModifyBodyParams> extends Plugin {
+    private readonly callable?;
+    constructor(callable?: ModifyBodyCallable<T>);
+    modifyBody(params: T): void;
+}

package/plugins/definition/ElasticsearchBodyModifierPlugin.js

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