@webiny/api-headless-cms-ddb-es 0.0.0-mt-3 → 0.0.0-unstable.06b2ede40f

package/helpers/createElasticsearchQueryBody.js

@@ -1,375 +0,0 @@
-"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;

package/helpers/fields.d.ts

@@ -1,77 +0,0 @@
-import { CmsModel, CmsModelField } from "@webiny/api-headless-cms/types";
-import { PluginsContainer } from "@webiny/plugins";
-declare type ModelFieldPath = string | ((value: string) => string);
-export interface ModelField {
-    unmappedType?: string;
-    keyword?: boolean;
-    isSearchable: boolean;
-    isSortable: boolean;
-    type: string;
-    isSystemField?: boolean;
-    field: CmsModelField;
-    path?: ModelFieldPath;
-}
-export declare type ModelFields = Record<string, ModelField>;
-export declare const systemFields: {
-    id: {
-        type: string;
-        isSystemField: boolean;
-        isSearchable: boolean;
-        isSortable: boolean;
-        field: CmsModelField;
-    };
-    entryId: {
-        type: string;
-        isSystemField: boolean;
-        isSearchable: boolean;
-        isSortable: boolean;
-        field: CmsModelField;
-    };
-    savedOn: {
-        type: string;
-        unmappedType: string;
-        keyword: boolean;
-        isSystemField: boolean;
-        isSearchable: boolean;
-        isSortable: boolean;
-        field: CmsModelField;
-    };
-    createdOn: {
-        type: string;
-        unmappedType: string;
-        keyword: boolean;
-        isSystemField: boolean;
-        isSearchable: boolean;
-        isSortable: boolean;
-        field: CmsModelField;
-    };
-    createdBy: {
-        type: string;
-        unmappedType: any;
-        isSystemField: boolean;
-        isSearchable: boolean;
-        isSortable: boolean;
-        path: string;
-        field: CmsModelField;
-    };
-    ownedBy: {
-        type: string;
-        unmappedType: any;
-        isSystemField: boolean;
-        isSearchable: boolean;
-        isSortable: boolean;
-        path: string;
-        field: CmsModelField;
-    };
-    version: {
-        type: string;
-        unmappedType: any;
-        keyword: boolean;
-        isSystemField: boolean;
-        isSearchable: boolean;
-        isSortable: boolean;
-        field: CmsModelField;
-    };
-};
-export declare const createModelFields: (plugins: PluginsContainer, model: CmsModel) => ModelFields;
-export {};

package/helpers/fields.js

@@ -1,174 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.systemFields = exports.createModelFields = void 0;
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-const createSystemField = field => {
-  if (!field.fieldId) {
-    throw new _error.default(`When creating system field it must have a "entryId".`, "SYSTEM_FIELD_ERROR", {
-      field
-    });
-  } else if (!field.type) {
-    throw new _error.default(`When creating system field it must have a "type".`, "SYSTEM_FIELD_ERROR", {
-      field
-    });
-  }
-
-  return field;
-};
-
-const systemFields = {
-  id: {
-    type: "text",
-    isSystemField: true,
-    isSearchable: true,
-    isSortable: true,
-    field: createSystemField({
-      fieldId: "id",
-      type: "text"
-    })
-  },
-  entryId: {
-    type: "text",
-    isSystemField: true,
-    isSearchable: true,
-    isSortable: true,
-    field: createSystemField({
-      fieldId: "entryId",
-      type: "text"
-    })
-  },
-  savedOn: {
-    type: "date",
-    unmappedType: "date",
-    keyword: false,
-    isSystemField: true,
-    isSearchable: true,
-    isSortable: true,
-    field: createSystemField({
-      fieldId: "savedOn",
-      type: "date",
-      settings: {
-        type: "dateTimeWithoutTimezone"
-      }
-    })
-  },
-  createdOn: {
-    type: "date",
-    unmappedType: "date",
-    keyword: false,
-    isSystemField: true,
-    isSearchable: true,
-    isSortable: true,
-    field: createSystemField({
-      fieldId: "createdOn",
-      type: "text",
-      settings: {
-        type: "dateTimeWithoutTimezone"
-      }
-    })
-  },
-  createdBy: {
-    type: "text",
-    unmappedType: undefined,
-    isSystemField: true,
-    isSearchable: true,
-    isSortable: false,
-    path: "createdBy.id",
-    field: createSystemField({
-      fieldId: "createdBy",
-      type: "text"
-    })
-  },
-  ownedBy: {
-    type: "text",
-    unmappedType: undefined,
-    isSystemField: true,
-    isSearchable: true,
-    isSortable: false,
-    path: "ownedBy.id",
-    field: createSystemField({
-      fieldId: "ownedBy",
-      type: "text"
-    })
-  },
-  version: {
-    type: "number",
-    unmappedType: undefined,
-    keyword: false,
-    isSystemField: true,
-    isSearchable: true,
-    isSortable: true,
-    field: createSystemField({
-      fieldId: "version",
-      type: "number"
-    })
-  }
-};
-/*
- * Create an object with key fieldType and options for that field
- */
-
-exports.systemFields = systemFields;
-
-const createModelFields = (plugins, model) => {
-  // collect all unmappedType from elastic plugins
-  const unmappedTypes = plugins.byType("cms-model-field-to-elastic-search").reduce((acc, plugin) => {
-    if (!plugin.unmappedType) {
-      return acc;
-    }
-
-    acc[plugin.fieldType] = plugin.unmappedType;
-    return acc;
-  }, {});
-  /**
-   * collect all field types from the plugins
-   */
-
-  const fieldTypePlugins = plugins.byType("cms-model-field-to-graphql").reduce((types, plugin) => {
-    const {
-      fieldType,
-      isSearchable,
-      isSortable
-    } = plugin;
-    types[fieldType] = {
-      unmappedType: unmappedTypes[fieldType],
-      isSearchable: isSearchable === true,
-      isSortable: isSortable === true
-    };
-    return types;
-  }, {});
-  return model.fields.reduce((fields, field) => {
-    const {
-      fieldId,
-      type
-    } = field;
-
-    if (!fieldTypePlugins[type]) {
-      throw new _error.default(`There is no plugin for field type "${type}".`);
-    }
-
-    const {
-      isSearchable,
-      isSortable,
-      unmappedType
-    } = fieldTypePlugins[type];
-    fields[fieldId] = {
-      type,
-      isSearchable,
-      isSortable,
-      unmappedType: typeof unmappedType === "function" ? unmappedType(field) : undefined,
-      isSystemField: false,
-      field
-    };
-    return fields;
-  }, systemFields);
-};
-
-exports.createModelFields = createModelFields;

package/helpers/operatorPluginsList.d.ts

@@ -1,7 +0,0 @@
-import { ElasticsearchQueryBuilderOperatorPlugin } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin";
-import { PluginsContainer } from "@webiny/plugins";
-interface OperatorPlugins {
-    [operator: string]: ElasticsearchQueryBuilderOperatorPlugin;
-}
-export declare const operatorPluginsList: (plugins: PluginsContainer) => OperatorPlugins;
-export {};

package/helpers/operatorPluginsList.js

@@ -1,30 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.operatorPluginsList = void 0;
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _ElasticsearchQueryBuilderOperatorPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin");
-
-const operatorPluginsList = plugins => {
-  return plugins.byType(_ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin.type).reduce((plugins, plugin) => {
-    const operator = plugin.getOperator();
-
-    if (plugins[operator]) {
-      throw new _error.default("There is a ElasticsearchQueryBuilderOperatorPlugin defined for the operator.", "PLUGIN_ALREADY_EXISTS", {
-        operator: operator,
-        name: plugin.name || "unknown"
-      });
-    }
-
-    plugins[operator] = plugin;
-    return plugins;
-  }, {});
-};
-
-exports.operatorPluginsList = operatorPluginsList;

package/helpers/searchPluginsList.d.ts

@@ -1,6 +0,0 @@
-import { ElasticsearchQueryBuilderValueSearchPlugin } from "../types";
-import { PluginsContainer } from "@webiny/plugins";
-export interface ElasticsearchQuerySearchValuePlugins {
-    [fieldType: string]: ElasticsearchQueryBuilderValueSearchPlugin;
-}
-export declare const searchPluginsList: (plugins: PluginsContainer) => ElasticsearchQuerySearchValuePlugins;

package/helpers/transformValueForSearch.d.ts

@@ -1,9 +0,0 @@
-import { ElasticsearchQuerySearchValuePlugins } from "./searchPluginsList";
-import { CmsModelField } from "@webiny/api-headless-cms/types";
-interface Params {
-    plugins: ElasticsearchQuerySearchValuePlugins;
-    field: CmsModelField;
-    value: any;
-}
-export declare const transformValueForSearch: (args: Params) => any;
-export {};

package/helpers/transformValueForSearch.js

@@ -1,26 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformValueForSearch = void 0;
-
-const transformValueForSearch = args => {
-  const {
-    field,
-    plugins,
-    value
-  } = args;
-  const plugin = plugins[field.type];
-
-  if (!plugin) {
-    return value;
-  }
-
-  return plugin.transform({
-    field,
-    value
-  });
-};
-
-exports.transformValueForSearch = transformValueForSearch;

package/operations/entry/elasticsearchFields.d.ts

@@ -1,2 +0,0 @@
-import { CmsEntryElasticsearchFieldPlugin } from "../../plugins/CmsEntryElasticsearchFieldPlugin";
-export declare const elasticsearchFields: CmsEntryElasticsearchFieldPlugin[];