@webiny/api-headless-cms-ddb 0.0.0-unstable.d4f203fa97 → 0.0.0-unstable.d65ec29d44

package/operations/entry/utils.js

@@ -1,690 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sortEntryItems = exports.filterItems = exports.buildModelFields = void 0;
-
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _sortBy = _interopRequireDefault(require("lodash/sortBy"));
-
-var _dotProp = _interopRequireDefault(require("dot-prop"));
-
-var _systemFields = require("./systemFields");
-
-var _ValueFilterPlugin = require("@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin");
-
-var _CmsEntryFieldFilterPathPlugin = require("../../plugins/CmsEntryFieldFilterPathPlugin");
-
-const VALUES_ATTRIBUTE = "values";
-
-const extractWhereParams = key => {
-  const result = key.split("_");
-  const fieldId = result.shift();
-
-  if (!fieldId) {
-    return null;
-  }
-
-  const rawOp = result.length === 0 ? "eq" : result.join("_");
-  /**
-   * When rawOp is not, it means it is equal negated so just return that.
-   */
-
-  if (rawOp === "not") {
-    return {
-      fieldId,
-      operation: "eq",
-      negate: true
-    };
-  }
-
-  const negate = rawOp.match("not_") !== null;
-  const operation = rawOp.replace("not_", "");
-  return {
-    fieldId,
-    operation,
-    negate
-  };
-};
-
-const transformValue = (value, transform) => {
-  if (Array.isArray(value)) {
-    return value.map(v => transform(v));
-  }
-
-  return transform(value);
-};
-
-const getFilterPlugin = params => {
-  const {
-    plugins,
-    operation
-  } = params;
-  const plugin = plugins[operation];
-
-  if (plugin) {
-    return plugin;
-  }
-
-  throw new _error.default(`There is no filter plugin for operation "${operation}".`, "FILTER_PLUGIN_ERROR", {
-    operation
-  });
-};
-
-const createValuePath = params => {
-  const {
-    field,
-    plugins,
-    index
-  } = params;
-  const {
-    fieldId
-  } = field;
-  const valuePathPlugin = plugins[field.type];
-  const basePath = _systemFields.systemFields[fieldId] ? "" : `${VALUES_ATTRIBUTE}.`;
-
-  if (!valuePathPlugin || valuePathPlugin.canUse(field) === false) {
-    return `${basePath}${fieldId}`;
-  }
-
-  const path = valuePathPlugin.createPath({
-    field,
-    index
-  });
-  return `${basePath}${path}`;
-};
-
-const isObjectFiltering = params => {
-  const {
-    value
-  } = params;
-
-  if (!value) {
-    return false;
-  } else if (Array.isArray(value) === true) {
-    return false;
-  } else if (value instanceof Date || !!value.toISOString) {
-    return false;
-  } else if (typeof value !== "object") {
-    return false;
-  }
-
-  return true;
-};
-
-const createFilters = params => {
-  const {
-    where,
-    plugins,
-    fields
-  } = params;
-  const filterPlugins = getMappedPlugins({
-    plugins,
-    type: _ValueFilterPlugin.ValueFilterPlugin.type,
-    property: "operation"
-  });
-  const transformValuePlugins = getMappedPlugins({
-    plugins,
-    type: "cms-field-filter-value-transform",
-    property: "fieldType"
-  });
-  const valuePathPlugins = getMappedPlugins({
-    plugins,
-    type: _CmsEntryFieldFilterPathPlugin.CmsEntryFieldFilterPathPlugin.type,
-    property: "fieldType"
-  });
-  const filters = [];
-
-  for (const key in where) {
-    if (where.hasOwnProperty(key) === false) {
-      continue;
-    }
-    /**
-     * At the moment we do not allow OR and AND conditional filtering, so throw an error on it.
-     */
-
-
-    if (key === "AND") {
-      throw new _error.default(`Conditional "AND" is currently disabled in the DynamoDB only deployment.`, "DISABLED_AND_CONDITIONAL");
-    } else if (key === "OR") {
-      throw new _error.default(`Conditional "OR" is currently disabled in the DynamoDB only deployment.`, "DISABLED_OR_CONDITIONAL");
-    }
-
-    const value = where[key];
-
-    if (value === undefined) {
-      continue;
-    }
-
-    const whereParams = extractWhereParams(key);
-
-    if (!whereParams) {
-      continue;
-    }
-
-    const {
-      fieldId,
-      operation,
-      negate
-    } = whereParams;
-    const field = fields[fieldId];
-
-    if (!field) {
-      throw new _error.default(`There is no field with the fieldId "${fieldId}".`, "FIELD_ERROR", {
-        fieldId
-      });
-    }
-
-    const transformValuePlugin = transformValuePlugins[field.def.type];
-
-    const transformValueCallable = value => {
-      if (!transformValuePlugin) {
-        return value;
-      }
-
-      return transformValuePlugin.transform({
-        field: field.def,
-        value
-      });
-    };
-
-    const objectFilteringParams = {
-      key,
-      value,
-      field: field.def
-    };
-
-    if (isObjectFiltering(objectFilteringParams)) {
-      const propertyFilters = Object.keys(value);
-
-      if (propertyFilters.length === 0) {
-        continue;
-      }
-
-      for (const propertyFilter of propertyFilters) {
-        const whereParams = extractWhereParams(propertyFilter);
-
-        if (!whereParams) {
-          continue;
-        }
-
-        const {
-          fieldId: propertyId,
-          operation: propertyOperation,
-          negate: propertyNegate
-        } = whereParams;
-        const filterPlugin = getFilterPlugin({
-          plugins: filterPlugins,
-          operation: propertyOperation
-        });
-        const basePath = createValuePath({
-          field: field.def,
-          plugins: valuePathPlugins
-        });
-        const multiValuesPath = field.def.multipleValues ? "%s." : "";
-        filters.push({
-          fieldId,
-          path: `${basePath}.${multiValuesPath}${propertyId}`,
-          filterPlugin,
-          negate: propertyNegate,
-          compareValue: transformValue(value[propertyFilter], transformValueCallable),
-          transformValue: transformValueCallable
-        });
-      }
-
-      continue;
-    }
-
-    const filterPlugin = getFilterPlugin({
-      plugins: filterPlugins,
-      operation
-    });
-    filters.push({
-      fieldId,
-      path: createValuePath({
-        field: field.def,
-        plugins: valuePathPlugins
-      }),
-      filterPlugin,
-      negate,
-      compareValue: transformValue(value, transformValueCallable),
-      transformValue: transformValueCallable
-    });
-  }
-
-  return filters;
-};
-/**
- * In case filter field is not multiple values one, return exact path.
- * If is multiple values field, use path without the last part
- */
-
-
-const getFilterValuePath = filter => {
-  if (filter.path.includes(".%s.") === false) {
-    return filter.path;
-  }
-
-  const paths = filter.path.split(".%s.");
-  return paths.shift();
-};
-
-const getFilterValuePropertyPath = filter => {
-  if (filter.path.includes(".%s.") === false) {
-    return null;
-  }
-
-  const paths = filter.path.split(".%s.");
-  return paths.pop() || null;
-};
-
-const execFilter = params => {
-  const {
-    value: plainValue,
-    filter
-  } = params;
-  const value = transformValue(plainValue, filter.transformValue);
-  const matched = filter.filterPlugin.matches({
-    value,
-    compareValue: filter.compareValue
-  });
-
-  if (filter.negate) {
-    return matched === false;
-  }
-
-  return matched;
-};
-
-/**
- * Unfortunately we must use the contains plugin directly as plugins do not support multi field searching.
- */
-const createFullTextSearch = ({
-  term,
-  fields: targetFields,
-  plugin
-}) => {
-  if (!term || term.trim().length === 0 || !targetFields || targetFields.length === 0) {
-    return null;
-  }
-
-  return async ({
-    item,
-    fromStorage,
-    fields
-  }) => {
-    for (const targetField of targetFields) {
-      const field = Object.values(fields).find(field => {
-        return field.def.fieldId === targetField;
-      });
-
-      if (!field) {
-        throw new _error.default(`Unknown field "${targetField}" in the model.`, "UNKNOWN_FIELD", {
-          target: targetField
-        });
-      }
-
-      const value = await fromStorage(field.def, item.values[targetField]);
-
-      if (!value) {
-        continue;
-      }
-
-      if (plugin.matches({
-        value,
-        compareValue: term
-      }) === true) {
-        return true;
-      }
-    }
-
-    return false;
-  };
-};
-
-const filterItems = async params => {
-  const {
-    items: records,
-    where,
-    plugins,
-    fields,
-    fromStorage,
-    fullTextSearch
-  } = params;
-  const filters = createFilters({
-    plugins,
-    where,
-    fields
-  });
-  const fullTextSearchPlugin = plugins.byType(_ValueFilterPlugin.ValueFilterPlugin.type).find(plugin => plugin.getOperation() === "contains");
-
-  if (!fullTextSearchPlugin) {
-    throw new _error.default(`Missing "contains" plugin to run the full-text search.`, "MISSING_PLUGIN");
-  }
-
-  const search = createFullTextSearch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, fullTextSearch), {}, {
-    plugin: fullTextSearchPlugin
-  }));
-  const promises = records.map(async record => {
-    /**
-     * We need to go through all the filters and apply them to the given record.
-     */
-    for (const filter of filters) {
-      /**
-       * In case is multiple values field, last part is removed from path.
-       * -> values.categories.id -> values.categories
-       */
-      const valuePath = getFilterValuePath(filter);
-
-      const rawValue = _dotProp.default.get(record, valuePath);
-
-      if (valuePath !== filter.path) {
-        /**
-         * Calculated is different than original because we need to search in the array of objects.
-         */
-        const propertyPath = getFilterValuePropertyPath(filter);
-
-        if (!propertyPath) {
-          console.log(`Cannot determine the property path of "${filter.path}".`);
-          continue;
-        }
-
-        const plainValue = await fromStorage(fields[filter.fieldId].def, rawValue);
-        /**
-         * We cannot go through the value because it is not array. Log the error and continue.
-         */
-
-        if (Array.isArray(plainValue) === false) {
-          console.log(`Cannot go through the value on ${valuePath} because it is not an array, and we expect it to be.`);
-          continue;
-        }
-
-        record = _dotProp.default.set(record, valuePath, plainValue);
-        const values = plainValue.map(value => {
-          return value[propertyPath];
-        });
-        const result = execFilter({
-          value: values,
-          filter
-        });
-
-        if (!result) {
-          return null;
-        }
-
-        continue;
-      }
-
-      const plainValue = await fromStorage(fields[filter.fieldId].def, rawValue);
-      /**
-       * If raw value is not same as the value after the storage transform, set the value to the items being filtered.
-       */
-
-      if (plainValue !== rawValue) {
-        record = _dotProp.default.set(record, filter.path, plainValue);
-      }
-
-      const result = execFilter({
-        value: plainValue,
-        filter
-      });
-
-      if (result === false) {
-        return null;
-      }
-    }
-    /**
-     * If we have full text search defined, run it. Otherwise just return the given record.
-     */
-
-
-    if (!search) {
-      return record;
-    }
-
-    const result = await search({
-      item: record,
-      fromStorage,
-      fields
-    });
-
-    if (!result) {
-      return null;
-    }
-
-    return record;
-  });
-  /**
-   * We run filtering as promises so it is a bit faster than in for ... of loop.
-   */
-
-  const results = await Promise.all(promises);
-  /**
-   * And filter out the null values which are returned when filter is not satisfied.
-   */
-
-  return results.filter(Boolean);
-};
-
-exports.filterItems = filterItems;
-
-const extractSort = (sortBy, fields) => {
-  const result = sortBy.split("_");
-
-  if (result.length !== 2) {
-    throw new _error.default("Problem in determining the sorting for the entry items.", "SORT_EXTRACT_ERROR", {
-      sortBy
-    });
-  }
-
-  const [fieldId, order] = result;
-  const modelField = Object.values(fields).find(field => {
-    return field.def.fieldId === fieldId;
-  });
-
-  if (!modelField) {
-    throw new _error.default("Sorting field does not exist in the content model.", "SORTING_FIELD_ERROR", {
-      fieldId,
-      fields
-    });
-  }
-
-  const valuePath = modelField.createPath({
-    field: modelField.def
-  });
-  return {
-    field: modelField,
-    fieldId,
-    valuePath,
-    reverse: order === "DESC"
-  };
-};
-
-const sortEntryItems = params => {
-  const {
-    items,
-    sort = [],
-    fields
-  } = params;
-
-  if (items.length <= 1) {
-    return items;
-  } else if (sort.length === 0) {
-    sort.push("savedOn_DESC");
-  } else if (sort.length > 1) {
-    throw new _error.default("Sorting is limited to a single field.", "SORT_MULTIPLE_FIELDS_ERROR", {
-      sort: sort
-    });
-  }
-
-  const [firstSort] = sort;
-
-  if (!firstSort) {
-    throw new _error.default("Empty sort array item.", "SORT_EMPTY_ERROR", {
-      sort
-    });
-  }
-
-  const {
-    fieldId,
-    field,
-    valuePath,
-    reverse
-  } = extractSort(firstSort, fields);
-  const itemsToSort = items.map(item => {
-    return {
-      id: item.id,
-      value: field.valueTransformer(_dotProp.default.get(item, valuePath))
-    };
-  });
-  const sortedItems = (0, _sortBy.default)(itemsToSort, "value");
-  const newItems = sortedItems.map(s => {
-    const item = items.find(i => i.id === s.id);
-
-    if (item) {
-      return item;
-    }
-
-    throw new _error.default("Could not find item by given id after the sorting.", "SORTING_ITEMS_ERROR", {
-      id: s.id,
-      sortingBy: fieldId,
-      reverse
-    });
-  });
-
-  if (!reverse) {
-    return newItems;
-  }
-
-  return newItems.reverse();
-};
-
-exports.sortEntryItems = sortEntryItems;
-
-const getMappedPlugins = params => {
-  const {
-    plugins: pluginsContainer,
-    type,
-    property
-  } = params;
-  const plugins = pluginsContainer.byType(type);
-
-  if (plugins.length === 0) {
-    throw new _error.default(`There are no plugins of type "${type}".`, "PLUGINS_ERROR", {
-      type
-    });
-  }
-
-  return plugins.reduce((collection, plugin) => {
-    const key = plugin[property];
-
-    if (typeof key !== "string") {
-      throw new _error.default("Property to map the plugins on must be a string.", "PLUGIN_PROPERTY_ERROR", {
-        type,
-        property
-      });
-    }
-
-    collection[key] = plugin;
-    return collection;
-  }, {});
-};
-
-const buildModelFields = ({
-  plugins,
-  model
-}) => {
-  const transformValuePlugins = getMappedPlugins({
-    plugins,
-    type: "cms-field-filter-value-transform",
-    property: "fieldType"
-  });
-  const valuePathPlugins = getMappedPlugins({
-    plugins,
-    type: _CmsEntryFieldFilterPathPlugin.CmsEntryFieldFilterPathPlugin.type,
-    property: "fieldType"
-  });
-  const fields = Object.values(_systemFields.systemFields).reduce((collection, field) => {
-    /**
-     * This should be caught on the tests runs and never actually happen on live system.
-     */
-    if (!field.fieldId) {
-      throw new _error.default("Missing system field `fieldId`.", "FIELD_ID_ERROR", {
-        field
-      });
-    }
-
-    const transformValuePlugin = transformValuePlugins[field.type];
-    const valuePathPlugin = valuePathPlugins[field.type];
-
-    let createPath = params => {
-      return params.field.fieldId;
-    };
-
-    if (valuePathPlugin) {
-      createPath = params => {
-        return valuePathPlugin.createPath(params);
-      };
-    }
-
-    collection[field.fieldId] = {
-      def: field,
-      valueTransformer: value => {
-        if (!transformValuePlugin) {
-          return value;
-        }
-
-        return transformValuePlugin.transform({
-          field,
-          value
-        });
-      },
-      createPath,
-      isSystemField: true
-    };
-    return collection;
-  }, {});
-  return model.fields.reduce((collection, field) => {
-    if (!field.fieldId) {
-      console.log(`Field "${field.storageId}" in model "${model.modelId}" is missing fieldId.`);
-      return collection;
-    }
-
-    const transformValuePlugin = transformValuePlugins[field.type];
-    const valuePathPlugin = valuePathPlugins[field.type];
-
-    let createPath = params => {
-      return `${VALUES_ATTRIBUTE}.${params.field.fieldId}`;
-    };
-
-    if (valuePathPlugin) {
-      createPath = params => {
-        return valuePathPlugin.createPath(params);
-      };
-    }
-
-    collection[field.fieldId] = {
-      def: field,
-      valueTransformer: value => {
-        if (!transformValuePlugin) {
-          return value;
-        }
-
-        return transformValuePlugin.transform({
-          field,
-          value
-        });
-      },
-      createPath
-    };
-    return collection;
-  }, fields);
-};
-
-exports.buildModelFields = buildModelFields;