@webiny/api-headless-cms-ddb-es/operations/entry/elasticsearch/body.js

DynamoDB and Elasticsearch storage operations plugin for Headless CMS API.

import { createModelFields } from "./fields.js";
import { createFullTextSearchFields } from "./fullTextSearchFields.js";
import { createInitialQuery } from "./initialQuery.js";
import { applyFullTextSearch } from "./fullTextSearch.js";
import { createElasticsearchSort } from "./sort.js";
import { createExecFiltering } from "./filtering/index.js";
import { assignMinimumShouldMatchToQuery } from "./assignMinimumShouldMatchToQuery.js";
export const createElasticsearchBody = ({
  plugins,
  model,
  params,
  fieldRegistry,
  fieldIndexRegistry,
  bodyModifiers,
  sortModifiers,
  queryModifiers,
  valueSearchRegistry,
  fullTextSearches,
  filterRegistry
}) => {
  const {
    fields,
    search: term,
    where,
    sort: initialSort,
    after,
    limit
  } = params;
  /**
   * We need the model fields constructed as a key -> field value, so we do not need to iterate through array when we require some field.
   */
  const modelFields = createModelFields({
    model,
    fieldRegistry,
    fieldIndexRegistry
  });

  /**
   * Filter query modifiers applicable to this model.
   */
  const applicableQueryModifiers = queryModifiers.filter(m => {
    return !m.modelId || m.modelId === model.modelId;
  });
  /**
   * Filter sort modifiers applicable to this model.
   */
  const applicableSortModifiers = sortModifiers.filter(m => !m.modelId || m.modelId === model.modelId);
  /**
   * Filter body modifiers applicable to this model.
   */
  const applicableBodyModifiers = bodyModifiers.filter(m => {
    return !m.modelId || m.modelId === model.modelId;
  });
  /**
   * We need the fields which we can search through via the full text search.
   *
   */
  const fullTextSearchFields = createFullTextSearchFields({
    fields: modelFields,
    term,
    targets: fields
  });
  /**
   * The initial elasticsearch query where we attach some default conditions we always need.
   */
  const query = createInitialQuery({
    where,
    model
  });
  /**
   * Apply the full text search, if term is set.
   */
  applyFullTextSearch({
    model,
    fullTextSearches,
    query,
    term,
    fields: fullTextSearchFields
  });
  const execFiltering = createExecFiltering({
    model,
    fields: modelFields,
    plugins,
    valueSearchRegistry,
    filterRegistry
  });
  execFiltering({
    where,
    query
  });
  for (const modifier of applicableQueryModifiers) {
    modifier.modifyQuery({
      query,
      model,
      where
    });
  }
  const sort = createElasticsearchSort({
    sort: initialSort,
    modelFields,
    model,
    valueSearchRegistry
  });
  for (const modifier of applicableSortModifiers) {
    modifier.modifySort({
      sort,
      model
    });
  }
  const boolQuery = {
    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
  };
  assignMinimumShouldMatchToQuery({
    query: boolQuery
  });
  const body = {
    query: {
      bool: boolQuery
    },
    sort,
    size: (limit || 0) + 1,
    search_after: after,
    track_total_hits: true
  };
  for (const modifier of applicableBodyModifiers) {
    modifier.modifyBody({
      body,
      model,
      where
    });
  }
  return body;
};

//# sourceMappingURL=body.js.map