@webiny/api-headless-cms-ddb 0.0.0-mt-2 → 0.0.0-unstable.085ff6572f

package/operations/entry/index.js

@@ -1,57 +1,76 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createEntriesStorageOperations = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _error = _interopRequireDefault(require("@webiny/error"));
-
 var _dataLoaders = require("./dataLoaders");
-
 var _types = require("@webiny/api-headless-cms/types");
-
-var _utils = require("./utils");
-
 var _keys = require("./keys");
-
 var _batchWrite = require("@webiny/db-dynamodb/utils/batchWrite");
-
 var _query = require("@webiny/db-dynamodb/utils/query");
-
 var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
-
 var _cursor = require("@webiny/utils/cursor");
-
 var _zeroPad = require("@webiny/utils/zeroPad");
-
 var _apiHeadlessCms = require("@webiny/api-headless-cms");
-
-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; }
-
+var _createFields = require("./filtering/createFields");
+var _filtering = require("./filtering");
 const createType = () => {
   return "cms.entry";
 };
-
 const createLatestType = () => {
   return `${createType()}.l`;
 };
-
 const createPublishedType = () => {
   return `${createType()}.p`;
 };
-
+const convertToStorageEntry = params => {
+  const {
+    model,
+    storageEntry
+  } = params;
+  const values = model.convertValueKeyToStorage({
+    fields: model.fields,
+    values: storageEntry.values
+  });
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+    values
+  });
+};
+const convertFromStorageEntry = params => {
+  const {
+    model,
+    storageEntry
+  } = params;
+  const values = model.convertValueKeyFromStorage({
+    fields: model.fields,
+    values: storageEntry.values
+  });
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+    values
+  });
+};
+const MAX_LIST_LIMIT = 10000;
 const createEntriesStorageOperations = params => {
   const {
     entity,
     plugins
   } = params;
+  let storageOperationsCmsModelPlugin;
+  const getStorageOperationsCmsModelPlugin = () => {
+    if (storageOperationsCmsModelPlugin) {
+      return storageOperationsCmsModelPlugin;
+    }
+    storageOperationsCmsModelPlugin = plugins.oneByType(_apiHeadlessCms.StorageOperationsCmsModelPlugin.type);
+    return storageOperationsCmsModelPlugin;
+  };
+  const getStorageOperationsModel = model => {
+    const plugin = getStorageOperationsCmsModelPlugin();
+    return plugin.getModel(model);
+  };
   const dataLoaders = new _dataLoaders.DataLoadersHandler({
     entity
   });
@@ -59,48 +78,54 @@ const createEntriesStorageOperations = params => {
     collection[plugin.fieldType] = plugin;
     return collection;
   }, {});
-
   const createStorageTransformCallable = model => {
     return (field, value) => {
       const plugin = storageTransformPlugins[field.type];
-
       if (!plugin) {
         return value;
       }
-
       return plugin.fromStorage({
         model,
         field,
         value,
-
         getStoragePlugin(fieldType) {
           return storageTransformPlugins[fieldType] || storageTransformPlugins["*"];
         },
-
         plugins
       });
     };
   };
-
-  const create = async (model, args) => {
+  const create = async (initialModel, params) => {
     const {
       entry,
-      storageEntry
-    } = args;
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
+      storageEntry: initialStorageEntry
+    } = params;
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const isPublished = entry.status === "published";
+    const locked = isPublished ? true : entry.locked;
+    const storageEntry = convertToStorageEntry({
+      model,
+      storageEntry: initialStorageEntry
+    });
     /**
      * We need to:
      *  - create new main entry item
-     *  - create new or update latest entry item
+     *  - create new or update the latest entry item
      */
-
-    const items = [entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      locked,
       PK: partitionKey,
       SK: (0, _keys.createRevisionSortKey)(entry),
       TYPE: createType(),
       GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
       GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-    })), entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    })), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      locked,
       PK: partitionKey,
       SK: (0, _keys.createLatestSortKey)(),
       TYPE: createLatestType(),
@@ -108,6 +133,19 @@ const createEntriesStorageOperations = params => {
       GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
     }))];
 
+    /**
+     * We need to create published entry if
+     */
+    if (isPublished) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked,
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)(),
+        TYPE: createLatestType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      })));
+    }
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -122,38 +160,41 @@ const createEntriesStorageOperations = params => {
         entry
       });
     }
-
-    return storageEntry;
+    return initialStorageEntry;
   };
-
-  const createRevisionFrom = async (model, params) => {
+  const createRevisionFrom = async (initialModel, params) => {
     const {
-      originalEntry,
       entry,
-      storageEntry,
-      latestEntry
+      storageEntry: initialStorageEntry
     } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(storageEntry);
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const storageEntry = convertToStorageEntry({
+      storageEntry: initialStorageEntry,
+      model
+    });
     /**
      * We need to:
      *  - create the main entry item
      *  - update the last entry item to a current one
      */
-
-    const items = [entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
       PK: partitionKey,
       SK: (0, _keys.createRevisionSortKey)(storageEntry),
       TYPE: createType(),
       GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
       GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-    })), entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    })), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
       PK: partitionKey,
       SK: (0, _keys.createLatestSortKey)(),
       TYPE: createLatestType(),
       GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
       GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
     }))];
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -165,8 +206,6 @@ const createEntriesStorageOperations = params => {
     } catch (ex) {
       throw new _error.default(ex.message || "Could not create revision from given entry.", ex.code || "CREATE_REVISION_ERROR", {
         error: ex,
-        originalEntry,
-        latestEntry,
         entry,
         storageEntry
       });
@@ -174,40 +213,57 @@ const createEntriesStorageOperations = params => {
     /**
      * There are no modifications on the entry created so just return the data.
      */
-
-
-    return storageEntry;
+    return initialStorageEntry;
   };
-
-  const update = async (model, params) => {
+  const update = async (initialModel, params) => {
     const {
-      originalEntry,
       entry,
-      storageEntry
+      storageEntry: initialStorageEntry
     } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(originalEntry);
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const isPublished = entry.status === "published";
+    const locked = isPublished ? true : entry.locked;
     const items = [];
+    const storageEntry = convertToStorageEntry({
+      model,
+      storageEntry: initialStorageEntry
+    });
     /**
      * We need to:
      *  - update the current entry
      *  - update the latest entry if the current entry is the latest one
      */
-
-    items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      locked,
       PK: partitionKey,
       SK: (0, _keys.createRevisionSortKey)(storageEntry),
       TYPE: createType(),
       GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
       GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
     })));
+    if (isPublished) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked,
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)(),
+        TYPE: createPublishedType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      })));
+    }
+
     /**
-     * We need the latest entry to update it as well if neccessary.
+     * We need the latest entry to update it as well if necessary.
      */
-
     const latestStorageEntry = await getLatestRevisionByEntryId(model, entry);
-
     if (latestStorageEntry && latestStorageEntry.id === entry.id) {
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked,
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
         TYPE: createLatestType(),
@@ -215,7 +271,6 @@ const createEntriesStorageOperations = params => {
         GSI1_SK: (0, _keys.createGSISortKey)(entry)
       })));
     }
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -224,46 +279,47 @@ const createEntriesStorageOperations = params => {
       dataLoaders.clearAll({
         model
       });
-      return storageEntry;
+      return initialStorageEntry;
     } catch (ex) {
       throw new _error.default(ex.message || "Could not update entry.", ex.code || "UPDATE_ERROR", {
         error: ex,
-        originalEntry,
         entry,
         latestStorageEntry
       });
     }
   };
-
-  const deleteEntry = async (model, params) => {
+  const deleteEntry = async (initialModel, params) => {
     const {
       entry
     } = params;
+    const id = entry.id || entry.entryId;
+    const model = getStorageOperationsModel(initialModel);
     const queryAllParams = {
       entity,
-      partitionKey: (0, _keys.createPartitionKey)(entry),
+      partitionKey: (0, _keys.createPartitionKey)({
+        id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       options: {
         gte: " "
       }
     };
     let records = [];
-
     try {
       records = await (0, _query.queryAll)(queryAllParams);
     } catch (ex) {
       throw new _error.default(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
         error: ex,
-        entry
+        id
       });
     }
-
     const items = records.map(item => {
       return entity.deleteBatch({
         PK: item.PK,
         SK: item.SK
       });
     });
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -276,44 +332,50 @@ const createEntriesStorageOperations = params => {
       throw new _error.default(ex.message || "Could not delete the entry.", ex.code || "DELETE_ENTRY_ERROR", {
         error: ex,
         partitionKey: queryAllParams.partitionKey,
-        entry
+        id
       });
     }
   };
-
-  const deleteRevision = async (model, params) => {
+  const deleteRevision = async (initialModel, params) => {
     const {
-      entryToDelete,
-      entryToSetAsLatest,
-      storageEntryToSetAsLatest
+      entry,
+      latestEntry,
+      latestStorageEntry: initialLatestStorageEntry
     } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(entryToDelete);
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
     const items = [entity.deleteBatch({
       PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entryToDelete)
+      SK: (0, _keys.createRevisionSortKey)(entry)
     })];
-    const publishedStorageEntry = await getPublishedRevisionByEntryId(model, entryToDelete);
+    const publishedStorageEntry = await getPublishedRevisionByEntryId(model, entry);
+
     /**
      * If revision we are deleting is the published one as well, we need to delete those records as well.
      */
-
-    if (publishedStorageEntry && entryToDelete.id === publishedStorageEntry.id) {
+    if (publishedStorageEntry && entry.id === publishedStorageEntry.id) {
       items.push(entity.deleteBatch({
         PK: partitionKey,
         SK: (0, _keys.createPublishedSortKey)()
       }));
     }
-
-    if (storageEntryToSetAsLatest) {
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntryToSetAsLatest), {}, {
+    if (initialLatestStorageEntry) {
+      const latestStorageEntry = convertToStorageEntry({
+        storageEntry: initialLatestStorageEntry,
+        model
+      });
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestStorageEntry), {}, {
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
         TYPE: createLatestType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-        GSI1_SK: (0, _keys.createGSISortKey)(storageEntryToSetAsLatest)
+        GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
       })));
     }
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -325,91 +387,170 @@ const createEntriesStorageOperations = params => {
     } catch (ex) {
       throw new _error.default(ex.message, ex.code, {
         error: ex,
-        entryToDelete,
-        entryToSetAsLatest
+        entry,
+        latestEntry
       });
     }
   };
-
-  const getAllRevisionsByIds = async (model, params) => {
-    return await dataLoaders.getAllEntryRevisions({
+  const deleteMultipleEntries = async (initialModel, params) => {
+    const {
+      entries
+    } = params;
+    const model = getStorageOperationsModel(initialModel);
+    /**
+     * First we need all the revisions of the entries we want to delete.
+     */
+    const revisions = await dataLoaders.getAllEntryRevisions({
       model,
-      ids: params.ids
+      ids: entries
+    });
+    /**
+     * Then we need to construct the queries for all the revisions and entries.
+     */
+    const items = [];
+    for (const id of entries) {
+      /**
+       * Latest item.
+       */
+      items.push(entity.deleteBatch({
+        PK: (0, _keys.createPartitionKey)({
+          id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: "L"
+      }));
+      /**
+       * Published item.
+       */
+      items.push(entity.deleteBatch({
+        PK: (0, _keys.createPartitionKey)({
+          id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: "P"
+      }));
+    }
+    /**
+     * Exact revisions of all the entries
+     */
+    for (const revision of revisions) {
+      items.push(entity.deleteBatch({
+        PK: (0, _keys.createPartitionKey)({
+          id: revision.id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: (0, _keys.createRevisionSortKey)({
+          version: revision.version
+        })
+      }));
+    }
+    await (0, _batchWrite.batchWriteAll)({
+      table: entity.table,
+      items
     });
   };
-
-  const getLatestRevisionByEntryId = async (model, params) => {
-    const result = await dataLoaders.getLatestRevisionByEntryId({
+  const getLatestRevisionByEntryId = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const items = await dataLoaders.getLatestRevisionByEntryId({
       model,
       ids: [params.id]
     });
-
-    if (result.length === 0) {
+    const item = items.shift() || null;
+    if (!item) {
       return null;
     }
-
-    return result.shift();
+    return convertFromStorageEntry({
+      storageEntry: item,
+      model
+    });
   };
-
-  const getPublishedRevisionByEntryId = async (model, params) => {
-    const result = await dataLoaders.getPublishedRevisionByEntryId({
+  const getPublishedRevisionByEntryId = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const items = await dataLoaders.getPublishedRevisionByEntryId({
       model,
       ids: [params.id]
     });
-
-    if (result.length === 0) {
+    const item = items.shift() || null;
+    if (!item) {
       return null;
     }
-
-    return result.shift();
+    return convertFromStorageEntry({
+      storageEntry: item,
+      model
+    });
   };
-
-  const getRevisionById = async (model, params) => {
-    const result = await dataLoaders.getRevisionById({
+  const getRevisionById = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const items = await dataLoaders.getRevisionById({
       model,
       ids: [params.id]
     });
-
-    if (result.length === 0) {
+    const item = items.shift() || null;
+    if (!item) {
       return null;
     }
-
-    return result.shift();
+    return convertFromStorageEntry({
+      storageEntry: item,
+      model
+    });
   };
-
-  const getRevisions = async (model, params) => {
-    return await dataLoaders.getAllEntryRevisions({
+  const getRevisions = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const items = await dataLoaders.getAllEntryRevisions({
       model,
       ids: [params.id]
     });
+    return items.map(item => {
+      return convertFromStorageEntry({
+        storageEntry: item,
+        model
+      });
+    });
   };
-
-  const getByIds = async (model, params) => {
-    return dataLoaders.getRevisionById({
+  const getByIds = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const items = await dataLoaders.getRevisionById({
       model,
       ids: params.ids
     });
+    return items.map(item => {
+      return convertFromStorageEntry({
+        storageEntry: item,
+        model
+      });
+    });
   };
-
-  const getLatestByIds = async (model, params) => {
-    return dataLoaders.getLatestRevisionByEntryId({
+  const getLatestByIds = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const items = await dataLoaders.getLatestRevisionByEntryId({
       model,
       ids: params.ids
     });
+    return items.map(item => {
+      return convertFromStorageEntry({
+        storageEntry: item,
+        model
+      });
+    });
   };
-
-  const getPublishedByIds = async (model, params) => {
-    return dataLoaders.getPublishedRevisionByEntryId({
+  const getPublishedByIds = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const items = await dataLoaders.getPublishedRevisionByEntryId({
       model,
       ids: params.ids
     });
+    return items.map(item => {
+      return convertFromStorageEntry({
+        storageEntry: item,
+        model
+      });
+    });
   };
-
-  const getPreviousRevision = async (model, params) => {
-    const {
-      tenant,
-      locale
-    } = model;
+  const getPreviousRevision = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
     const {
       entryId,
       version
@@ -417,13 +558,12 @@ const createEntriesStorageOperations = params => {
     const queryParams = {
       entity,
       partitionKey: (0, _keys.createPartitionKey)({
-        tenant,
-        locale,
+        tenant: model.tenant,
+        locale: model.locale,
         id: entryId
       }),
       options: {
         lt: `REV#${(0, _zeroPad.zeroPad)(version)}`,
-
         /**
          * We need to have extra checks because DynamoDB will return published or latest record if there is no REV# record.
          */
@@ -437,12 +577,18 @@ const createEntriesStorageOperations = params => {
         reverse: true
       }
     };
-
     try {
       const result = await (0, _query.queryOne)(queryParams);
-      return (0, _cleanup.cleanupItem)(entity, result);
+      const storageEntry = (0, _cleanup.cleanupItem)(entity, result);
+      if (!storageEntry) {
+        return null;
+      }
+      return convertFromStorageEntry({
+        storageEntry,
+        model
+      });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not get previous version of given entry.", ex.code || "GET_PREVIOUS_VERSION_ERROR", _objectSpread(_objectSpread({}, params), {}, {
+      throw new _error.default(ex.message || "Could not get previous version of given entry.", ex.code || "GET_PREVIOUS_VERSION_ERROR", (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
         error: ex,
         partitionKey: queryParams.partitionKey,
         options: queryParams.options,
@@ -450,16 +596,18 @@ const createEntriesStorageOperations = params => {
       }));
     }
   };
-
-  const list = async (model, params) => {
+  const list = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
     const {
       limit: initialLimit = 10,
-      where: originalWhere,
+      where: initialWhere,
       after,
-      sort
+      sort: sortBy,
+      fields,
+      search
     } = params;
-    const limit = initialLimit <= 0 || initialLimit >= 100 ? 100 : initialLimit;
-    const type = originalWhere.published ? "P" : "L";
+    const limit = initialLimit <= 0 || initialLimit >= MAX_LIST_LIMIT ? MAX_LIST_LIMIT : initialLimit;
+    const type = initialWhere.published ? "P" : "L";
     const queryAllParams = {
       entity,
       partitionKey: (0, _keys.createGSIPartitionKey)(model, type),
@@ -468,10 +616,9 @@ const createEntriesStorageOperations = params => {
         gte: " "
       }
     };
-    let records = [];
-
+    let storageEntries = [];
     try {
-      records = await (0, _query.queryAll)(queryAllParams);
+      storageEntries = await (0, _query.queryAll)(queryAllParams);
     } catch (ex) {
       throw new _error.default(ex.message, "QUERY_ENTRIES_ERROR", {
         error: ex,
@@ -479,8 +626,7 @@ const createEntriesStorageOperations = params => {
         options: queryAllParams.options
       });
     }
-
-    if (records.length === 0) {
+    if (storageEntries.length === 0) {
       return {
         hasMoreItems: false,
         totalCount: 0,
@@ -488,46 +634,61 @@ const createEntriesStorageOperations = params => {
         items: []
       };
     }
-
-    const where = _objectSpread({}, originalWhere);
-
+    const where = (0, _objectSpread2.default)({}, initialWhere);
     delete where["published"];
     delete where["latest"];
-    delete where["locale"];
-    delete where["tenant"];
     /**
-     * We need a object containing field, transformers and paths.
+     * We need an object containing field, transformers and paths.
      * Just build it here and pass on into other methods that require it to avoid mapping multiple times.
      */
-
-    const modelFields = (0, _utils.buildModelFields)({
+    const modelFields = (0, _createFields.createFields)({
       plugins,
-      model
+      fields: model.fields
     });
+    const fromStorage = createStorageTransformCallable(model);
+    /**
+     * Let's transform records from storage ones to regular ones, so we do not need to do it later.
+     *
+     * This is always being done, but at least its in parallel.
+     */
+    const records = await Promise.all(storageEntries.map(async storageEntry => {
+      const entry = convertFromStorageEntry({
+        storageEntry,
+        model
+      });
+      for (const field of model.fields) {
+        entry.values[field.fieldId] = await fromStorage(field, entry.values[field.fieldId]);
+      }
+      return entry;
+    }));
     /**
      * Filter the read items via the code.
      * It will build the filters out of the where input and transform the values it is using.
      */
-
-    const filteredItems = await (0, _utils.filterItems)({
+    const filteredItems = (0, _filtering.filter)({
       items: records,
       where,
       plugins,
       fields: modelFields,
-      fromStorage: createStorageTransformCallable(model)
+      fullTextSearch: {
+        term: search,
+        fields: fields || []
+      }
     });
     const totalCount = filteredItems.length;
+
     /**
      * Sorting is also done via the code.
      * It takes the sort input and sorts by it via the lodash sortBy method.
      */
-
-    const sortedItems = (0, _utils.sortEntryItems)({
+    const sortedItems = (0, _filtering.sort)({
+      model,
+      plugins,
       items: filteredItems,
-      sort,
+      sort: sortBy,
       fields: modelFields
     });
-    const start = (0, _cursor.decodeCursor)(after) || 0;
+    const start = parseInt((0, _cursor.decodeCursor)(after) || "0") || 0;
     const hasMoreItems = totalCount > start + limit;
     const end = limit > totalCount + start + limit ? undefined : start + limit;
     const slicedItems = sortedItems.slice(start, end);
@@ -535,8 +696,7 @@ const createEntriesStorageOperations = params => {
      * Although we do not need a cursor here, we will use it as such to keep it standardized.
      * Number is simply encoded.
      */
-
-    const cursor = totalCount > start + limit ? (0, _cursor.encodeCursor)(start + limit) : null;
+    const cursor = totalCount > start + limit ? (0, _cursor.encodeCursor)(`${start + limit}`) : null;
     return {
       hasMoreItems,
       totalCount,
@@ -544,165 +704,58 @@ const createEntriesStorageOperations = params => {
       items: (0, _cleanup.cleanupItems)(entity, slicedItems)
     };
   };
-
-  const get = async (model, params) => {
+  const get = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
     const {
       items
-    } = await list(model, _objectSpread(_objectSpread({}, params), {}, {
+    } = await list(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
       limit: 1
     }));
-
-    if (items.length === 0) {
-      return null;
-    }
-
-    return items.shift();
+    return items.shift() || null;
   };
-
-  const requestChanges = async (model, params) => {
+  const publish = async (initialModel, params) => {
     const {
       entry,
-      storageEntry,
-      originalEntry
+      storageEntry: initialStorageEntry
     } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
-    /**
-     * We need to:
-     *  - update the existing entry
-     *  - update latest version - if existing entry is the latest version
-     */
-
-    const items = [entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      TYPE: createType(),
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-      GSI1_SK: (0, _keys.createGSISortKey)(entry)
-    }))];
-    /**
-     * We need the latest entry to see if something needs to be updated along side the request changes one.
-     */
-
-    const latestStorageEntry = await getLatestRevisionByEntryId(model, entry);
-
-    if (latestStorageEntry.id === entry.id) {
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: createLatestType(),
-        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-        GSI1_SK: (0, _keys.createGSISortKey)(entry)
-      })));
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not execute the request changes batch.", ex.code || "REQUEST_CHANGES_ERROR", {
-        entry,
-        originalEntry
-      });
-    }
-
-    return entry;
-  };
-
-  const requestReview = async (model, params) => {
-    const {
-      entry,
-      storageEntry,
-      originalEntry
-    } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
-    /**
-     * We need to:
-     *  - update existing entry
-     *  - update latest entry - if existing entry is the latest entry
-     */
-
-    const items = [entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      TYPE: createType(),
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-      GSI1_SK: (0, _keys.createGSISortKey)(entry)
-    }))];
-    /**
-     * We need the latest entry to see if something needs to be updated along side the request review one.
-     */
-
-    const latestStorageEntry = await getLatestRevisionByEntryId(model, entry);
-
-    if (latestStorageEntry.id === entry.id) {
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: createLatestType(),
-        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-        GSI1_SK: (0, _keys.createGSISortKey)(entry)
-      })));
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-      return entry;
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not execute request review batch.", ex.code || "REQUEST_REVIEW_ERROR", {
-        entry,
-        storageEntry,
-        originalEntry
-      });
-    }
-  };
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
 
-  const publish = async (model, params) => {
-    const {
-      entry,
-      storageEntry
-    } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
     /**
-     * We need the latest and published entries to see if something needs to be updated along side the publishing one.
+     * We need the latest and published entries to see if something needs to be updated alongside the publishing one.
      */
-
-    const latestStorageEntry = await getLatestRevisionByEntryId(model, entry);
-    const publishedStorageEntry = await getPublishedRevisionByEntryId(model, entry);
+    const initialLatestStorageEntry = await getLatestRevisionByEntryId(model, entry);
+    const initialPublishedStorageEntry = await getPublishedRevisionByEntryId(model, entry);
+    const storageEntry = convertToStorageEntry({
+      model,
+      storageEntry: initialStorageEntry
+    });
     /**
      * We need to update:
      *  - current entry revision sort key
      *  - published sort key
-     *  - latest sort key - if entry updated is actually latest
+     *  - the latest sort key - if entry updated is actually latest
      *  - previous published entry to unpublished status - if any previously published entry
      */
-
-    const items = [entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
       PK: partitionKey,
       SK: (0, _keys.createRevisionSortKey)(entry),
       TYPE: createType(),
       GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
       GSI1_SK: (0, _keys.createGSISortKey)(entry)
-    })), entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    })), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
       PK: partitionKey,
       SK: (0, _keys.createPublishedSortKey)(),
       TYPE: createPublishedType(),
       GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
       GSI1_SK: (0, _keys.createGSISortKey)(entry)
     }))];
-
-    if (entry.id === latestStorageEntry.id) {
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    if (initialLatestStorageEntry && entry.id === initialLatestStorageEntry.id) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
         TYPE: createLatestType(),
@@ -710,9 +763,12 @@ const createEntriesStorageOperations = params => {
         GSI1_SK: (0, _keys.createGSISortKey)(entry)
       })));
     }
-
-    if (publishedStorageEntry) {
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, publishedStorageEntry), {}, {
+    if (initialPublishedStorageEntry && initialPublishedStorageEntry.id !== entry.id) {
+      const publishedStorageEntry = convertToStorageEntry({
+        storageEntry: initialPublishedStorageEntry,
+        model
+      });
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedStorageEntry), {}, {
         PK: partitionKey,
         SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry),
         TYPE: createType(),
@@ -721,7 +777,6 @@ const createEntriesStorageOperations = params => {
         GSI1_SK: (0, _keys.createGSISortKey)(publishedStorageEntry)
       })));
     }
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -730,47 +785,53 @@ const createEntriesStorageOperations = params => {
       dataLoaders.clearAll({
         model
       });
-      return entry;
+      return initialStorageEntry;
     } catch (ex) {
       throw new _error.default(ex.message || "Could not execute the publishing batch.", ex.code || "PUBLISH_ERROR", {
         entry,
-        latestStorageEntry,
-        publishedStorageEntry
+        latestStorageEntry: initialLatestStorageEntry,
+        publishedStorageEntry: initialPublishedStorageEntry
       });
     }
   };
-
-  const unpublish = async (model, params) => {
+  const unpublish = async (initialModel, params) => {
     const {
       entry,
-      storageEntry
+      storageEntry: initialStorageEntry
     } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const storageEntry = convertToStorageEntry({
+      storageEntry: initialStorageEntry,
+      model
+    });
     /**
      * We need to:
      *  - delete currently published entry
      *  - update current entry revision with new data
-     *  - update latest entry status - if entry being unpublished is latest
+     *  - update the latest entry status - if entry being unpublished is latest
      */
-
     const items = [entity.deleteBatch({
       PK: partitionKey,
       SK: (0, _keys.createPublishedSortKey)()
-    }), entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    }), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
       PK: partitionKey,
       SK: (0, _keys.createRevisionSortKey)(entry),
       TYPE: createType(),
       GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
       GSI1_SK: (0, _keys.createGSISortKey)(entry)
     }))];
+
     /**
-     * We need the latest entry to see if something needs to be updated along side the unpublishing one.
+     * We need the latest entry to see if something needs to be updated alongside the unpublishing one.
      */
-
     const latestStorageEntry = await getLatestRevisionByEntryId(model, entry);
-
-    if (entry.id === latestStorageEntry.id) {
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    if (latestStorageEntry && entry.id === latestStorageEntry.id) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
         TYPE: createLatestType(),
@@ -778,7 +839,6 @@ const createEntriesStorageOperations = params => {
         GSI1_SK: (0, _keys.createGSISortKey)(entry)
       })));
     }
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -787,7 +847,7 @@ const createEntriesStorageOperations = params => {
       dataLoaders.clearAll({
         model
       });
-      return storageEntry;
+      return initialStorageEntry;
     } catch (ex) {
       throw new _error.default(ex.message || "Could not execute unpublish batch.", ex.code || "UNPUBLISH_ERROR", {
         entry,
@@ -795,29 +855,64 @@ const createEntriesStorageOperations = params => {
       });
     }
   };
-
+  const getUniqueFieldValues = async (model, params) => {
+    const {
+      where,
+      fieldId
+    } = params;
+    const field = model.fields.find(f => f.fieldId === fieldId);
+    if (!field) {
+      throw new _error.default(`Could not find field with given "fieldId" value.`, "FIELD_NOT_FOUND", {
+        fieldId
+      });
+    }
+    const {
+      items
+    } = await list(model, {
+      where,
+      limit: MAX_LIST_LIMIT
+    });
+    const result = {};
+    for (const item of items) {
+      const fieldValue = item.values[field.fieldId];
+      if (!fieldValue) {
+        continue;
+      }
+      const values = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
+      if (values.length === 0) {
+        continue;
+      }
+      for (const value of values) {
+        var _result$value;
+        result[value] = {
+          value,
+          count: (((_result$value = result[value]) === null || _result$value === void 0 ? void 0 : _result$value.count) || 0) + 1
+        };
+      }
+    }
+    return Object.values(result).sort((a, b) => a.value > b.value ? 1 : b.value > a.value ? -1 : 0).sort((a, b) => b.count - a.count);
+  };
   return {
     create,
     createRevisionFrom,
     update,
     delete: deleteEntry,
     deleteRevision,
+    deleteMultipleEntries,
     getPreviousRevision,
     getPublishedByIds,
     getLatestByIds,
     getByIds,
     getRevisionById,
     getPublishedRevisionByEntryId,
-    getAllRevisionsByIds,
     getLatestRevisionByEntryId,
     get,
     getRevisions,
-    requestChanges,
-    requestReview,
     publish,
     list,
-    unpublish
+    unpublish,
+    dataLoaders,
+    getUniqueFieldValues
   };
 };
-
 exports.createEntriesStorageOperations = createEntriesStorageOperations;