@webiny/api-elasticsearch 0.0.0-mt-1

package/sort.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSort = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const sortRegExp = new RegExp(/^([a-zA-Z-0-9_]+)_(ASC|DESC)$/);
+
+const createSort = params => {
+  const {
+    sort,
+    defaults,
+    fieldPlugins
+  } = params;
+
+  if (!sort || sort.length === 0) {
+    const {
+      field,
+      order,
+      unmappedType
+    } = defaults || {};
+    /**
+     * We say that our system defaults is always id since all records we create have some kind of primary ID.
+     */
+
+    return {
+      [field || "id.keyword"]: {
+        order: order || "desc",
+        unmapped_type: unmappedType || undefined
+      }
+    };
+  }
+
+  return sort.reduce((acc, value) => {
+    const match = value.match(sortRegExp);
+
+    if (!match) {
+      throw new _error.default(`Cannot sort by "${value}".`);
+    }
+
+    const [, field, initialOrder] = match;
+    const order = initialOrder.toLowerCase() === "asc" ? "asc" : "desc";
+    const plugin = fieldPlugins[field] || fieldPlugins["*"];
+
+    if (!plugin) {
+      throw new _error.default(`Missing plugin for the field "${field}"`, "PLUGIN_SORT_ERROR", {
+        field
+      });
+    }
+    /**
+     * In case field plugin is the global one, change the * with actual field name.
+     * Custom path methods will return their own values anyway so replacing * will not matter.
+     */
+
+
+    const path = plugin.getPath(field);
+    acc[path] = plugin.getSortOptions(order);
+    return acc;
+  }, {});
+};
+
+exports.createSort = createSort;

package/types.d.ts

@@ -0,0 +1,49 @@
+import { Client } from "@elastic/elasticsearch";
+import { BoolQueryConfig as esBoolQueryConfig, Query as esQuery } from "elastic-ts";
+import { ContextInterface } from "@webiny/handler/types";
+export * from "elastic-ts";
+export interface ElasticsearchContext extends ContextInterface {
+    elasticsearch: Client;
+}
+/**
+ * To simplify our plugins, we say that query contains arrays of objects, not single objects.
+ * And that they all are defined as empty arrays at the start.
+ */
+export interface ElasticsearchBoolQueryConfig extends esBoolQueryConfig {
+    must: esQuery[];
+    filter: esQuery[];
+    should: esQuery[];
+    must_not: esQuery[];
+}
+/**
+ * Definitions of possible Elasticsearch operators.
+ *
+ * @category Elasticsearch
+ */
+export declare type ElasticsearchQueryOperator = "eq" | "not" | "in" | "not_in" | "contains" | "not_contains" | "between" | "not_between" | "gt" | "gte" | "lt" | "lte";
+/**
+ * Definition for arguments of the ElasticsearchQueryBuilderOperatorPlugin.apply method.
+ *
+ * @see ElasticsearchQueryBuilderOperatorPlugin.apply
+ *
+ * @category Plugin
+ * @category Elasticsearch
+ */
+export interface ElasticsearchQueryBuilderArgsPlugin {
+    /**
+     * A full path to the field. Including the ".keyword" if it is added.
+     */
+    path: string;
+    /**
+     * A path to the field, plain.
+     */
+    basePath: string;
+    /**
+     * Value to apply.
+     */
+    value: any;
+    /**
+     * Is path containing the ".keyword"
+     */
+    keyword: boolean;
+}

package/types.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _elasticTs = require("elastic-ts");
+
+Object.keys(_elasticTs).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _elasticTs[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _elasticTs[key];
+    }
+  });
+});

package/where.d.ts

@@ -0,0 +1,17 @@
+import { ElasticsearchBoolQueryConfig } from "./types";
+import { ElasticsearchFieldPlugin } from "./plugins/definition/ElasticsearchFieldPlugin";
+import { ElasticsearchQueryBuilderOperatorPlugin } from "./plugins/definition/ElasticsearchQueryBuilderOperatorPlugin";
+declare type Records<T> = Record<string, T>;
+export interface Params {
+    query: ElasticsearchBoolQueryConfig;
+    where: Records<any>;
+    fields: Records<ElasticsearchFieldPlugin>;
+    operators: Records<ElasticsearchQueryBuilderOperatorPlugin>;
+}
+export interface ParseWhereKeyResult {
+    field: string;
+    operator: string;
+}
+export declare const parseWhereKey: (key: string) => ParseWhereKeyResult;
+export declare const applyWhere: (params: Params) => void;
+export {};

package/where.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseWhereKey = exports.applyWhere = void 0;
+
+var _ElasticsearchFieldPlugin = require("./plugins/definition/ElasticsearchFieldPlugin");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const parseWhereKeyRegExp = new RegExp(/^([a-zA-Z0-9]+)(_[a-zA-Z0-9_]+)?$/);
+
+const parseWhereKey = key => {
+  const match = key.match(parseWhereKeyRegExp);
+
+  if (!match) {
+    throw new Error(`It is not possible to search by key "${key}"`);
+  }
+
+  const [, field, operation = "eq"] = match;
+
+  if (!field.match(/^([a-zA-Z]+)$/)) {
+    throw new Error(`Cannot filter by "${field}".`);
+  }
+
+  const operator = operation.match(/^_/) ? operation.substr(1) : operation;
+  return {
+    field,
+    operator
+  };
+};
+
+exports.parseWhereKey = parseWhereKey;
+const ALL = _ElasticsearchFieldPlugin.ElasticsearchFieldPlugin.ALL;
+
+const applyWhere = params => {
+  const {
+    query,
+    where,
+    fields,
+    operators
+  } = params;
+
+  for (const key in where) {
+    if (where.hasOwnProperty(key) === false) {
+      continue;
+    }
+
+    const initialValue = where[key];
+    /**
+     * There is a possibility that undefined is sent as a value, so just skip it.
+     */
+
+    if (initialValue === undefined) {
+      continue;
+    }
+
+    const {
+      field,
+      operator
+    } = parseWhereKey(key);
+    const fieldPlugin = fields[field] || fields[ALL];
+
+    if (!fieldPlugin) {
+      throw new _error.default(`Missing plugin for the field "${field}".`, "PLUGIN_WHERE_ERROR", {
+        field
+      });
+    }
+
+    const operatorPlugin = operators[operator];
+
+    if (!operatorPlugin) {
+      throw new _error.default(`Missing plugin for the operator "${operator}"`, "PLUGIN_WHERE_ERROR", {
+        operator
+      });
+    }
+    /**
+     * Get the path but in the case of * (all fields, replace * with the field.
+     * Custom path would return its own value anyways.
+     */
+
+
+    const path = fieldPlugin.getPath(field);
+    const basePath = fieldPlugin.getBasePath(field);
+    /**
+     * Transform the value for the search.
+     */
+
+    const value = fieldPlugin.toSearchValue({
+      value: initialValue,
+      path,
+      basePath
+    });
+    operatorPlugin.apply(query, {
+      value,
+      path,
+      basePath,
+      keyword: fieldPlugin.keyword
+    });
+  }
+};
+
+exports.applyWhere = applyWhere;