@webiny/api-headless-cms-ddb-es 0.0.0-mt-1

package/elasticsearch/indexing/objectIndexing.js

@@ -0,0 +1,200 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+const processToIndex = ({
+  fields,
+  value: sourceValue,
+  rawValue: sourceRawValue,
+  getFieldIndexPlugin,
+  getFieldTypePlugin,
+  plugins,
+  model
+}) => {
+  const reducer = (values, field) => {
+    const plugin = getFieldIndexPlugin(field.type);
+    const {
+      value,
+      rawValue
+    } = plugin.toIndex({
+      model,
+      field,
+      value: sourceValue[field.fieldId],
+      rawValue: sourceRawValue[field.fieldId],
+      getFieldIndexPlugin,
+      getFieldTypePlugin,
+      plugins
+    });
+
+    if (value !== undefined) {
+      values.value[field.fieldId] = value;
+    }
+
+    if (rawValue !== undefined) {
+      values.rawValue[field.fieldId] = rawValue;
+    }
+
+    return values;
+  };
+
+  return fields.reduce(reducer, {
+    value: {},
+    rawValue: {}
+  });
+};
+
+const processFromIndex = ({
+  fields,
+  value: sourceValue,
+  rawValue: sourceRawValue,
+  getFieldIndexPlugin,
+  getFieldTypePlugin,
+  plugins,
+  model
+}) => {
+  const reducer = (values, field) => {
+    const plugin = getFieldIndexPlugin(field.type);
+    const value = plugin.fromIndex({
+      plugins,
+      model,
+      field,
+      value: sourceValue[field.fieldId],
+      rawValue: sourceRawValue[field.fieldId],
+      getFieldIndexPlugin,
+      getFieldTypePlugin
+    });
+
+    if (value !== undefined) {
+      values[field.fieldId] = value;
+    }
+
+    return values;
+  };
+
+  return fields.reduce(reducer, {});
+};
+
+var _default = () => ({
+  type: "cms-model-field-to-elastic-search",
+  name: "cms-model-field-to-elastic-search-object",
+  fieldType: "object",
+
+  toIndex({
+    plugins,
+    model,
+    field,
+    value: initialValue,
+    rawValue: initialRawValue,
+    getFieldIndexPlugin,
+    getFieldTypePlugin
+  }) {
+    if (!initialValue) {
+      return {
+        value: null
+      };
+    }
+
+    const fields = field.settings.fields;
+    /**
+     * In "object" field, value is either an object or an array of objects.
+     */
+
+    if (field.multipleValues) {
+      const result = {
+        value: [],
+        rawValue: []
+      };
+
+      for (const key in initialValue) {
+        const {
+          value,
+          rawValue
+        } = processToIndex({
+          value: initialValue[key],
+          rawValue: initialRawValue[key],
+          getFieldIndexPlugin,
+          getFieldTypePlugin,
+          model,
+          plugins,
+          fields
+        });
+
+        if (Object.keys(value).length > 0) {
+          result.value.push(value);
+        }
+
+        if (Object.keys(rawValue).length > 0) {
+          result.rawValue.push(rawValue);
+        }
+      }
+
+      return {
+        value: result.value.length > 0 ? result.value : undefined,
+        rawValue: result.rawValue.length > 0 ? result.rawValue : undefined
+      };
+    }
+
+    return processToIndex({
+      value: initialValue,
+      rawValue: initialRawValue,
+      getFieldIndexPlugin,
+      getFieldTypePlugin,
+      model,
+      plugins,
+      fields
+    });
+  },
+
+  fromIndex({
+    field,
+    value,
+    rawValue,
+    model,
+    plugins,
+    getFieldIndexPlugin,
+    getFieldTypePlugin
+  }) {
+    if (!value) {
+      return null;
+    }
+
+    const fields = field.settings.fields;
+    /**
+     * In "object" field, value is either an object or an array of objects.
+     */
+
+    if (field.multipleValues) {
+      /**
+       * Why this `value || rawValue || []`?
+       * It's possible that an object contains all non-indexable fields, or vice-versa, and so
+       * we can never be sure which array we can reliably use as a source of values.
+       */
+      const source = value || rawValue || [];
+      return source.map((_, index) => processFromIndex({
+        value: value ? value[index] || {} : {},
+        rawValue: rawValue ? rawValue[index] || {} : {},
+        getFieldIndexPlugin,
+        getFieldTypePlugin,
+        model,
+        plugins,
+        fields
+      }));
+    }
+
+    return processFromIndex({
+      value,
+      rawValue,
+      getFieldIndexPlugin,
+      getFieldTypePlugin,
+      model,
+      plugins,
+      fields
+    });
+  }
+
+});
+
+exports.default = _default;

package/elasticsearch/indexing/richTextIndexing.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToElasticsearchPlugin } from "../../types";
+declare const _default: () => CmsModelFieldToElasticsearchPlugin;
+export default _default;

package/elasticsearch/indexing/richTextIndexing.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _default = () => ({
+  type: "cms-model-field-to-elastic-search",
+  name: "cms-model-field-to-elastic-search-rich-text",
+  fieldType: "rich-text",
+
+  toIndex({
+    value
+  }) {
+    // TODO: convert rich-text object to a searchable string to offer full-text search at some point
+
+    /**
+     * We want to store rich-text value as a "rawValue", meaning it wont' be indexed by ES.
+     */
+    return {
+      rawValue: value
+    };
+  },
+
+  fromIndex({
+    rawValue
+  }) {
+    return rawValue;
+  }
+
+});
+
+exports.default = _default;

package/elasticsearch/search/index.d.ts

@@ -0,0 +1,3 @@
+import { ElasticsearchQueryBuilderValueSearchPlugin } from "../../types";
+declare const _default: () => ElasticsearchQueryBuilderValueSearchPlugin[];
+export default _default;

package/elasticsearch/search/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _timeSearch = _interopRequireDefault(require("./timeSearch"));
+
+var _refSearch = _interopRequireDefault(require("./refSearch"));
+
+var _default = () => [(0, _timeSearch.default)(), (0, _refSearch.default)()];
+
+exports.default = _default;

package/elasticsearch/search/refSearch.d.ts

@@ -0,0 +1,3 @@
+import { ElasticsearchQueryBuilderValueSearchPlugin } from "../../types";
+declare const _default: () => ElasticsearchQueryBuilderValueSearchPlugin;
+export default _default;

package/elasticsearch/search/refSearch.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _default = () => ({
+  type: "cms-elastic-search-query-builder-value-search",
+  name: "cms-elastic-search-query-builder-value-search-ref-field",
+  fieldType: "ref",
+  transform: ({
+    value
+  }) => {
+    return value;
+  },
+  createPath: ({
+    field
+  }) => {
+    return `values.${field.fieldId}.entryId`;
+  }
+});
+
+exports.default = _default;

package/elasticsearch/search/timeSearch.d.ts

@@ -0,0 +1,3 @@
+import { ElasticsearchQueryBuilderValueSearchPlugin } from "../../types";
+declare const _default: () => ElasticsearchQueryBuilderValueSearchPlugin;
+export default _default;

package/elasticsearch/search/timeSearch.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _default = () => ({
+  type: "cms-elastic-search-query-builder-value-search",
+  name: "elastic-search-query-builder-value-search-time",
+  fieldType: "datetime",
+  transform: ({
+    field,
+    value
+  }) => {
+    if (field.settings.type !== "time") {
+      return value;
+    }
+
+    const [hours, minutes, seconds = 0] = value.split(":").map(Number);
+    return hours * 60 * 60 + minutes * 60 + seconds;
+  }
+});
+
+exports.default = _default;

package/helpers/createElasticsearchQueryBody.d.ts

@@ -0,0 +1,11 @@
+import { CmsEntryListParams, CmsModel } from "@webiny/api-headless-cms/types";
+import { SearchBody as esSearchBody } from "@webiny/api-elasticsearch/types";
+import { PluginsContainer } from "@webiny/plugins";
+interface CreateElasticsearchParams {
+    plugins: PluginsContainer;
+    model: CmsModel;
+    args: CmsEntryListParams;
+    parentPath?: string;
+}
+export declare const createElasticsearchQueryBody: (params: CreateElasticsearchParams) => esSearchBody;
+export {};

package/helpers/createElasticsearchQueryBody.js

@@ -0,0 +1,375 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElasticsearchQueryBody = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _operatorPluginsList = require("./operatorPluginsList");
+
+var _transformValueForSearch = require("./transformValueForSearch");
+
+var _searchPluginsList = require("./searchPluginsList");
+
+var _cursors = require("@webiny/api-elasticsearch/cursors");
+
+var _sort = require("@webiny/api-elasticsearch/sort");
+
+var _fields = require("./fields");
+
+var _CmsEntryElasticsearchFieldPlugin = require("../plugins/CmsEntryElasticsearchFieldPlugin");
+
+var _where = require("@webiny/api-elasticsearch/where");
+
+var _entry = require("../operations/entry");
+
+var _CmsEntryElasticsearchQueryModifierPlugin = require("../plugins/CmsEntryElasticsearchQueryModifierPlugin");
+
+var _CmsEntryElasticsearchSortModifierPlugin = require("../plugins/CmsEntryElasticsearchSortModifierPlugin");
+
+var _CmsEntryElasticsearchBodyModifierPlugin = require("../plugins/CmsEntryElasticsearchBodyModifierPlugin");
+
+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 specialFields = ["published", "latest", "locale", "tenant"];
+const noKeywordFields = ["date", "number", "boolean"];
+
+const createElasticsearchSortParams = args => {
+  const {
+    sort,
+    modelFields,
+    parentPath,
+    searchPlugins
+  } = args;
+
+  if (!sort || sort.length === 0) {
+    return undefined;
+  }
+
+  const sortPlugins = Object.values(modelFields).reduce((plugins, modelField) => {
+    const searchPlugin = searchPlugins[modelField.type];
+    plugins[modelField.field.fieldId] = new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+      unmappedType: modelField.unmappedType,
+      keyword: hasKeyword(modelField),
+      sortable: modelField.isSortable,
+      searchable: modelField.isSearchable,
+      field: modelField.field.fieldId,
+      path: createFieldPath({
+        parentPath,
+        modelField: modelField,
+        searchPlugin
+      })
+    });
+    return plugins;
+  }, {});
+  return (0, _sort.createSort)({
+    fieldPlugins: sortPlugins,
+    sort
+  });
+};
+/**
+ * Latest and published are specific in Elasticsearch to that extend that they are tagged in the __type property.
+ * We allow either published or either latest.
+ * Latest is used in the manage API and published in the read API.
+ */
+
+
+const createInitialQueryValue = args => {
+  const {
+    where
+  } = args;
+  const query = {
+    must: [],
+    must_not: [],
+    should: [],
+    filter: []
+  }; // When ES index is shared between tenants, we need to filter records by tenant ID
+
+  const sharedIndex = process.env.ELASTICSEARCH_SHARED_INDEXES === "true";
+
+  if (sharedIndex) {
+    query.must.push({
+      term: {
+        "tenant.keyword": where.tenant
+      }
+    });
+  }
+
+  delete where["tenant"];
+
+  if (where.locale) {
+    query.must.push({
+      term: {
+        "locale.keyword": where.locale
+      }
+    });
+  }
+
+  delete where["locale"];
+  /**
+   * We must transform published and latest where args into something that is understandable by our Elasticsearch
+   */
+
+  if (where.published === true) {
+    query.must.push({
+      term: {
+        "__type.keyword": (0, _entry.createPublishedType)()
+      }
+    });
+  } else if (where.latest === true) {
+    query.must.push({
+      term: {
+        "__type.keyword": (0, _entry.createLatestType)()
+      }
+    });
+  } // we do not allow not published and not latest
+  else if (where.published === false) {
+    throw new _error.default(`Cannot call Elasticsearch query with "published" set at false.`, "ELASTICSEARCH_UNSUPPORTED_QUERY", {
+      where
+    });
+  } else if (where.latest === false) {
+    throw new _error.default(`Cannot call Elasticsearch query with "latest" set at false.`, "ELASTICSEARCH_UNSUPPORTED_QUERY", {
+      where
+    });
+  } //
+
+
+  return query;
+};
+
+const createFieldPath = ({
+  modelField,
+  searchPlugin,
+  parentPath
+}) => {
+  let path;
+
+  if (searchPlugin && typeof searchPlugin.createPath === "function") {
+    path = searchPlugin.createPath({
+      field: modelField.field
+    });
+  } else if (typeof modelField.path === "function") {
+    path = modelField.path(modelField.field.fieldId);
+  }
+
+  if (!path) {
+    path = modelField.path || modelField.field.fieldId || modelField.field.id;
+  }
+
+  return modelField.isSystemField || !parentPath || path.match(parentPath) ? path : `${parentPath}.${path}`;
+};
+
+const hasKeyword = modelField => {
+  /**
+   * We defined some field types that MUST have no keyword added to the field path
+   */
+  if (noKeywordFields.includes(modelField.type)) {
+    return false;
+  } else if (modelField.unmappedType) {
+    /**
+     * If modelField has unmapped type defined, do not add keyword.
+     */
+    return false;
+  } else if (modelField.keyword === false) {
+    /**
+     * And if specifically defined that modelField has no keyword, do not add it.
+     */
+    return false;
+  }
+  /**
+   * All other fields have keyword added.
+   */
+
+
+  return true;
+};
+/*
+ * Iterate through where keys and apply plugins where necessary
+ */
+
+
+const execElasticsearchBuildQueryPlugins = params => {
+  const {
+    where: initialWhere,
+    modelFields,
+    parentPath,
+    plugins,
+    searchPlugins
+  } = params;
+
+  const where = _objectSpread({}, initialWhere);
+
+  const query = createInitialQueryValue(_objectSpread(_objectSpread({}, params), {}, {
+    where
+  }));
+  /**
+   * Always remove special fields, as these do not exist in Elasticsearch.
+   */
+
+  for (const sf of specialFields) {
+    delete where[sf];
+  }
+
+  if (Object.keys(where).length === 0) {
+    return query;
+  }
+
+  const operatorPlugins = (0, _operatorPluginsList.operatorPluginsList)(plugins);
+
+  for (const key in where) {
+    if (where.hasOwnProperty(key) === false) {
+      continue;
+    }
+    /**
+     * We do not need to go further if value is undefined.
+     * There are few hardcoded possibilities when value is undefined, for example, ownedBy.
+     */
+
+
+    if (where[key] === undefined) {
+      continue;
+    }
+
+    const {
+      field,
+      operator
+    } = (0, _where.parseWhereKey)(key);
+    const modelField = modelFields[field];
+
+    if (!modelField) {
+      throw new _error.default(`There is no field "${field}".`);
+    }
+
+    const {
+      isSearchable = false,
+      field: cmsField
+    } = modelField;
+
+    if (!isSearchable) {
+      throw new _error.default(`Field "${field}" is not searchable.`);
+    }
+
+    const plugin = operatorPlugins[operator];
+
+    if (!plugin) {
+      throw new _error.default("Operator plugin missing.", "PLUGIN_MISSING", {
+        operator
+      });
+    }
+
+    const fieldSearchPlugin = searchPlugins[modelField.type];
+    const value = (0, _transformValueForSearch.transformValueForSearch)({
+      plugins: searchPlugins,
+      field: cmsField,
+      value: where[key]
+    });
+    const fieldPath = createFieldPath({
+      searchPlugin: fieldSearchPlugin,
+      modelField,
+      parentPath: parentPath
+    });
+    const keyword = hasKeyword(modelField);
+    plugin.apply(query, {
+      basePath: fieldPath,
+      path: keyword ? `${fieldPath}.keyword` : fieldPath,
+      value,
+      keyword
+    });
+  }
+
+  return query;
+};
+
+const createElasticsearchQueryBody = params => {
+  const {
+    plugins,
+    model,
+    args,
+    parentPath = null
+  } = params;
+  const {
+    where,
+    after,
+    limit,
+    sort: initialSort
+  } = args;
+  const modelFields = (0, _fields.createModelFields)(plugins, model);
+  const searchPlugins = (0, _searchPluginsList.searchPluginsList)(plugins);
+  const query = execElasticsearchBuildQueryPlugins({
+    model,
+    plugins,
+    where,
+    modelFields,
+    parentPath,
+    searchPlugins
+  });
+  const queryPlugins = plugins.byType(_CmsEntryElasticsearchQueryModifierPlugin.CmsEntryElasticsearchQueryModifierPlugin.type).filter(pl => {
+    return !pl.modelId || pl.modelId === model.modelId;
+  });
+
+  for (const pl of queryPlugins) {
+    pl.modifyQuery({
+      query,
+      model,
+      where
+    });
+  }
+
+  const sort = createElasticsearchSortParams({
+    plugins,
+    sort: initialSort,
+    modelFields,
+    parentPath,
+    model,
+    searchPlugins
+  });
+  const sortPlugins = plugins.byType(_CmsEntryElasticsearchSortModifierPlugin.CmsEntryElasticsearchSortModifierPlugin.type).filter(pl => {
+    return !pl.modelId || pl.modelId === model.modelId;
+  });
+
+  for (const pl of sortPlugins) {
+    pl.modifySort({
+      sort,
+      model
+    });
+  }
+
+  const body = {
+    query: {
+      bool: {
+        must: query.must.length > 0 ? query.must : undefined,
+        must_not: query.must_not.length > 0 ? query.must_not : undefined,
+        should: query.should.length > 0 ? query.should : undefined,
+        filter: query.filter.length > 0 ? query.filter : undefined
+      }
+    },
+    sort,
+    size: limit + 1,
+    // eslint-disable-next-line
+    search_after: (0, _cursors.decodeCursor)(after),
+    // eslint-disable-next-line
+    track_total_hits: true
+  };
+  const bodyPlugins = plugins.byType(_CmsEntryElasticsearchBodyModifierPlugin.CmsEntryElasticsearchBodyModifierPlugin.type).filter(pl => {
+    return !pl.modelId || pl.modelId === model.modelId;
+  });
+
+  for (const pl of bodyPlugins) {
+    pl.modifyBody({
+      body,
+      model
+    });
+  }
+
+  return body;
+};
+
+exports.createElasticsearchQueryBody = createElasticsearchQueryBody;