@webiny/api-headless-cms-ddb 0.0.0-mt-3 → 0.0.0-unstable.40876133bb

package/operations/entry/utils.js

@@ -1,15 +1,17 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 _lodash = _interopRequireDefault(require("lodash.sortby"));
+var _sortBy = _interopRequireDefault(require("lodash/sortBy"));
 
 var _dotProp = _interopRequireDefault(require("dot-prop"));
 
@@ -17,11 +19,18 @@ 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.
@@ -52,6 +61,63 @@ const transformValue = (value, transform) => {
   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,
@@ -70,15 +136,33 @@ const createFilters = params => {
   });
   const valuePathPlugins = getMappedPlugins({
     plugins,
-    type: "cms-field-filter-path",
+    type: _CmsEntryFieldFilterPathPlugin.CmsEntryFieldFilterPathPlugin.type,
     property: "fieldType"
   });
-  return Object.keys(where).map(key => {
+  const filters = [];
+
+  for (const key in where) {
+    if (where.hasOwnProperty(key) === false) {
+      continue;
+    }
+
+    const value = where[key];
+
+    if (value === undefined) {
+      continue;
+    }
+
+    const whereParams = extractWhereParams(key);
+
+    if (!whereParams) {
+      continue;
+    }
+
     const {
       fieldId,
       operation,
       negate
-    } = extractWhereParams(key);
+    } = whereParams;
     const field = fields[fieldId];
 
     if (!field) {
@@ -88,33 +172,6 @@ const createFilters = params => {
     }
 
     const transformValuePlugin = transformValuePlugins[field.def.type];
-    const valuePathPlugin = valuePathPlugins[field.def.type];
-    let targetValuePath;
-    /**
-     * add the base path if field is not a system field
-     * pathPlugin should not know about that
-     */
-
-    const basePath = _systemFields.systemFields[fieldId] ? "" : `${VALUES_ATTRIBUTE}.`;
-
-    if (valuePathPlugin) {
-      targetValuePath = valuePathPlugin.createPath({
-        field: field.def
-      });
-    } else if (_systemFields.systemFields[fieldId]) {
-      targetValuePath = fieldId;
-    } else {
-      targetValuePath = field.def.fieldId;
-    }
-
-    const valuePath = `${basePath}${targetValuePath}`;
-    const filterPlugin = filterPlugins[operation];
-
-    if (!filterPlugin) {
-      throw new _error.default(`There is no filter plugin for operation "${operation}".`, "FILTER_PLUGIN_ERROR", {
-        operation
-      });
-    }
 
     const transformValueCallable = value => {
       if (!transformValuePlugin) {
@@ -127,42 +184,232 @@ const createFilters = params => {
       });
     };
 
-    return {
+    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: valuePath,
+      path: createValuePath({
+        field: field.def,
+        plugins: valuePathPlugins
+      }),
       filterPlugin,
       negate,
-      compareValue: transformValue(where[key], transformValueCallable),
+      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,
+    items: records,
     where,
     plugins,
     fields,
-    fromStorage
+    fromStorage,
+    fullTextSearch
   } = params;
   const filters = createFilters({
     plugins,
     where,
     fields
   });
-  const results = [];
+  const fullTextSearchPlugin = plugins.byType(_ValueFilterPlugin.ValueFilterPlugin.type).find(plugin => plugin.getOperation() === "contains");
 
-  for (const key in items) {
-    if (items.hasOwnProperty(key) === false) {
-      continue;
-    }
-
-    const item = items[key];
-    let passed = true;
+  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) {
-      const rawValue = _dotProp.default.get(item, filter.path);
+      /**
+       * 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);
       /**
@@ -170,46 +417,49 @@ const filterItems = async params => {
        */
 
       if (plainValue !== rawValue) {
-        items[key] = _dotProp.default.set(item, filter.path, plainValue);
+        record = _dotProp.default.set(record, filter.path, plainValue);
       }
 
-      const value = transformValue(plainValue, filter.transformValue);
-      const matched = filter.filterPlugin.matches({
-        value,
-        compareValue: filter.compareValue
+      const result = execFilter({
+        value: plainValue,
+        filter
       });
 
-      if ((filter.negate ? !matched : matched) === false) {
-        passed = false;
-        break;
+      if (result === false) {
+        return null;
       }
     }
+    /**
+     * If we have full text search defined, run it. Otherwise just return the given record.
+     */
 
-    if (!passed) {
-      continue;
+
+    if (!search) {
+      return record;
     }
 
-    results.push(item);
-  }
+    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.
+   */
 
-  return results; // return items.filter(item => {
-  //     for (const filter of filters) {
-  //         const plainValue = await fromStorage(
-  //             fields[filter.fieldId].def,
-  //             dotProp.get(item, filter.path)
-  //         );
-  //
-  //         const value = transformValue(plainValue, filter.transformValue);
-  //         const matched = filter.filterPlugin.matches({
-  //             value,
-  //             compareValue: filter.compareValue
-  //         });
-  //         if ((filter.negate ? !matched : matched) === false) {
-  //             return false;
-  //         }
-  //     }
-  //     return true;
-  // });
+  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;
@@ -218,13 +468,15 @@ 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_ERROR", {
+    throw new _error.default("Problem in determining the sorting for the entry items.", "SORT_EXTRACT_ERROR", {
       sortBy
     });
   }
 
   const [fieldId, order] = result;
-  const modelField = fields[fieldId];
+  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", {
@@ -233,8 +485,11 @@ const extractSort = (sortBy, fields) => {
     });
   }
 
-  const valuePath = modelField.valuePath;
+  const valuePath = modelField.createPath({
+    field: modelField.def
+  });
   return {
+    field: modelField,
     fieldId,
     valuePath,
     reverse: order === "DESC"
@@ -253,7 +508,7 @@ const sortEntryItems = params => {
   } 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_ERROR", {
+    throw new _error.default("Sorting is limited to a single field.", "SORT_MULTIPLE_FIELDS_ERROR", {
       sort: sort
     });
   }
@@ -261,24 +516,24 @@ const sortEntryItems = params => {
   const [firstSort] = sort;
 
   if (!firstSort) {
-    throw new _error.default("Empty sort array item.", "SORT_ERROR", {
+    throw new _error.default("Empty sort array item.", "SORT_EMPTY_ERROR", {
       sort
     });
   }
 
   const {
     fieldId,
+    field,
     valuePath,
     reverse
   } = extractSort(firstSort, fields);
-  const field = fields[fieldId];
   const itemsToSort = items.map(item => {
     return {
       id: item.id,
       value: field.valueTransformer(_dotProp.default.get(item, valuePath))
     };
   });
-  const sortedItems = (0, _lodash.default)(itemsToSort, "value");
+  const sortedItems = (0, _sortBy.default)(itemsToSort, "value");
   const newItems = sortedItems.map(s => {
     const item = items.find(i => i.id === s.id);
 
@@ -342,18 +597,30 @@ const buildModelFields = ({
   });
   const valuePathPlugins = getMappedPlugins({
     plugins,
-    type: "cms-field-filter-path",
+    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 valuePath;
+
+    let createPath = params => {
+      return params.field.fieldId;
+    };
 
     if (valuePathPlugin) {
-      valuePath = valuePathPlugin.createPath({
-        field
-      });
+      createPath = params => {
+        return valuePathPlugin.createPath(params);
+      };
     }
 
     collection[field.fieldId] = {
@@ -368,23 +635,30 @@ const buildModelFields = ({
           value
         });
       },
-      valuePath: valuePath || field.fieldId,
+      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 valuePath;
+
+    let createPath = params => {
+      return `${VALUES_ATTRIBUTE}.${params.field.fieldId}`;
+    };
 
     if (valuePathPlugin) {
-      valuePath = valuePathPlugin.createPath({
-        field
-      });
+      createPath = params => {
+        return valuePathPlugin.createPath(params);
+      };
     }
 
-    const targetValuePath = `${VALUES_ATTRIBUTE}.${valuePath || field.fieldId}`;
     collection[field.fieldId] = {
       def: field,
       valueTransformer: value => {
@@ -397,7 +671,7 @@ const buildModelFields = ({
           value
         });
       },
-      valuePath: targetValuePath || field.fieldId
+      createPath
     };
     return collection;
   }, fields);