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

package/operations/entry/index.js

@@ -1,89 +1,41 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createPublishedType = exports.createLatestType = exports.createEntriesStorageOperations = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
+exports.createEntriesStorageOperations = void 0;
+var _error = _interopRequireDefault(require("@webiny/error"));
 var _types = require("@webiny/api-headless-cms/types");
-
 var _helpers = require("../../helpers");
-
-var _configurations = _interopRequireDefault(require("../../configurations"));
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
-
-var _lodash2 = _interopRequireDefault(require("lodash.omit"));
-
-var _compression = require("@webiny/api-elasticsearch/compression");
-
-var _batchWrite = require("@webiny/db-dynamodb/utils/batchWrite");
-
+var _configurations = require("../../configurations");
+var _dbDynamodb = require("@webiny/db-dynamodb");
 var _dataLoaders = require("./dataLoaders");
-
 var _keys = require("./keys");
-
-var _query = require("@webiny/db-dynamodb/utils/query");
-
-var _limit = require("@webiny/api-elasticsearch/limit");
-
-var _cursors = require("@webiny/api-elasticsearch/cursors");
-
-var _get = require("@webiny/db-dynamodb/utils/get");
-
+var _apiElasticsearch = require("@webiny/api-elasticsearch");
 var _utils = require("@webiny/utils");
-
-var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
-
-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 createType = () => {
-  return "cms.entry";
-};
-
-const createLatestType = () => {
-  return `${createType()}.l`;
-};
-
-exports.createLatestType = createLatestType;
-
-const createPublishedType = () => {
-  return `${createType()}.p`;
-};
-
-exports.createPublishedType = createPublishedType;
-
-const getEntryData = entry => {
-  return _objectSpread(_objectSpread({}, (0, _lodash2.default)(entry, ["PK", "SK", "published", "latest"])), {}, {
-    TYPE: createType(),
-    __type: createType()
+var _body = require("./elasticsearch/body");
+var _logIgnoredEsResponseError = require("./elasticsearch/logIgnoredEsResponseError");
+var _shouldIgnoreEsResponseError = require("./elasticsearch/shouldIgnoreEsResponseError");
+var _recordType = require("./recordType");
+var _apiHeadlessCms = require("@webiny/api-headless-cms");
+var _transformations = require("./transformations");
+var _convertEntryKeys = require("./transformations/convertEntryKeys");
+var _constants = require("@webiny/api-headless-cms/constants");
+const convertToStorageEntry = params => {
+  const {
+    model,
+    storageEntry
+  } = params;
+  const values = model.convertValueKeyToStorage({
+    fields: model.fields,
+    values: storageEntry.values
   });
+  return {
+    ...storageEntry,
+    values
+  };
 };
-
-const getESLatestEntryData = async (plugins, entry) => {
-  return (0, _compression.compress)(plugins, _objectSpread(_objectSpread({}, getEntryData(entry)), {}, {
-    latest: true,
-    TYPE: createLatestType(),
-    __type: createLatestType()
-  }));
-};
-
-const getESPublishedEntryData = async (plugins, entry) => {
-  return (0, _compression.compress)(plugins, _objectSpread(_objectSpread({}, getEntryData(entry)), {}, {
-    published: true,
-    TYPE: createPublishedType(),
-    __type: createPublishedType()
-  }));
-};
-
 const createEntriesStorageOperations = params => {
   const {
     entity,
@@ -91,48 +43,95 @@ const createEntriesStorageOperations = params => {
     elasticsearch,
     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
   });
-
-  const create = async (model, params) => {
+  const create = async (initialModel, params) => {
     const {
-      entry,
-      storageEntry
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
     } = params;
-    const esEntry = (0, _helpers.prepareEntryToIndex)({
+    const model = getStorageOperationsModel(initialModel);
+    const isPublished = initialEntry.status === "published";
+    const locked = isPublished ? true : initialEntry.locked;
+    initialEntry.locked = locked;
+    initialStorageEntry.locked = locked;
+    const transformer = (0, _transformations.createTransformer)({
       plugins,
       model,
-      entry: (0, _lodash.default)(entry),
-      storageEntry: (0, _lodash.default)(storageEntry)
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
     });
-
+    const {
+      entry,
+      storageEntry
+    } = transformer.transformEntryKeys();
+    const esEntry = transformer.transformToIndex();
     const {
       index: esIndex
-    } = _configurations.default.es({
+    } = _configurations.configurations.es({
       model
     });
-
-    const esLatestData = await getESLatestEntryData(plugins, esEntry);
     const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createRevisionSortKey)(entry)
     };
     const latestKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createLatestSortKey)()
     };
-    const items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), revisionKeys), {}, {
-      TYPE: createType()
-    })), entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), latestKeys), {}, {
-      TYPE: createLatestType()
-    }))];
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
+    const publishedKeys = {
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
+      SK: (0, _keys.createPublishedSortKey)()
+    };
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        locked,
+        ...revisionKeys,
+        TYPE: (0, _recordType.createRecordType)()
+      }, {
+        ...storageEntry,
+        locked,
+        ...latestKeys,
+        TYPE: (0, _recordType.createLatestRecordType)()
+      }]
+    });
+    if (isPublished) {
+      entityBatch.put({
+        ...storageEntry,
+        locked,
+        ...publishedKeys,
+        TYPE: (0, _recordType.createPublishedRecordType)()
       });
+    }
+    try {
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
@@ -143,12 +142,25 @@ const createEntriesStorageOperations = params => {
         storageEntry
       });
     }
-
-    try {
-      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
+    const esLatestData = await transformer.getElasticsearchLatestEntryData();
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity,
+      put: [{
+        ...latestKeys,
         index: esIndex,
         data: esLatestData
-      }));
+      }]
+    });
+    if (isPublished) {
+      const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
+      elasticsearchEntityBatch.put({
+        ...publishedKeys,
+        index: esIndex,
+        data: esPublishedData
+      });
+    }
+    try {
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
       throw new _error.default(ex.message || "Could not insert entry data into the Elasticsearch DynamoDB table.", ex.code || "CREATE_ES_ENTRY_ERROR", {
         error: ex,
@@ -156,391 +168,1064 @@ const createEntriesStorageOperations = params => {
         esEntry
       });
     }
-
-    return storageEntry;
+    return initialStorageEntry;
   };
-
-  const createRevisionFrom = async (model, params) => {
+  const createRevisionFrom = async (initialModel, params) => {
+    const {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const model = getStorageOperationsModel(initialModel);
+    const transformer = (0, _transformations.createTransformer)({
+      plugins,
+      model,
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    });
     const {
-      originalEntry,
       entry,
       storageEntry
-    } = params;
+    } = transformer.transformEntryKeys();
     const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createRevisionSortKey)(entry)
     };
     const latestKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createLatestSortKey)()
     };
-    const esEntry = (0, _helpers.prepareEntryToIndex)({
-      plugins,
-      model,
-      entry: (0, _lodash.default)(entry),
-      storageEntry: (0, _lodash.default)(storageEntry)
-    });
-    const esLatestData = await getESLatestEntryData(plugins, esEntry);
-    const items = [entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      TYPE: createType()
-    }, revisionKeys)), entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      TYPE: createLatestType()
-    }, latestKeys))];
+    const publishedKeys = {
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
+      SK: (0, _keys.createPublishedSortKey)()
+    };
 
-    const {
-      index
-    } = _configurations.default.es({
-      model
+    // We'll need this flag below.
+    const isPublished = entry.status === "published";
+    const esLatestData = await transformer.getElasticsearchLatestEntryData();
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        TYPE: (0, _recordType.createRecordType)(),
+        ...revisionKeys
+      }, {
+        ...storageEntry,
+        TYPE: (0, _recordType.createLatestRecordType)(),
+        ...latestKeys
+      }]
     });
+    if (isPublished) {
+      entityBatch.put({
+        ...storageEntry,
+        TYPE: (0, _recordType.createPublishedRecordType)(),
+        ...publishedKeys
+      });
 
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
+      // Unpublish previously published revision (if any).
+      const [publishedRevisionStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+        model,
+        ids: [entry.id]
       });
+      if (publishedRevisionStorageEntry) {
+        entityBatch.put({
+          ...publishedRevisionStorageEntry,
+          PK: (0, _keys.createPartitionKey)({
+            id: publishedRevisionStorageEntry.id,
+            locale: model.locale,
+            tenant: model.tenant
+          }),
+          SK: (0, _keys.createRevisionSortKey)(publishedRevisionStorageEntry),
+          TYPE: (0, _recordType.createRecordType)(),
+          status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED
+        });
+      }
+    }
+    try {
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
       throw new _error.default(ex.message || "Could not create revision from given entry in the DynamoDB table.", ex.code || "CREATE_REVISION_ERROR", {
         error: ex,
-        originalEntry,
         entry,
         storageEntry
       });
     }
-    /**
-     * Update the "latest" entry item in the Elasticsearch
-     */
-
-
-    try {
-      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
-        index,
+    const {
+      index: esIndex
+    } = _configurations.configurations.es({
+      model
+    });
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity,
+      put: [{
+        ...latestKeys,
+        index: esIndex,
         data: esLatestData
-      }));
+      }]
+    });
+    if (isPublished) {
+      const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
+      elasticsearchEntityBatch.put({
+        ...publishedKeys,
+        index: esIndex,
+        data: esPublishedData
+      });
+    }
+    try {
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
       throw new _error.default(ex.message || "Could not update latest entry in the DynamoDB Elasticsearch table.", ex.code || "CREATE_REVISION_ERROR", {
         error: ex,
-        originalEntry,
         entry
       });
     }
     /**
      * 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 {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const model = getStorageOperationsModel(initialModel);
+    const transformer = (0, _transformations.createTransformer)({
+      plugins,
+      model,
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    });
     const {
-      originalEntry,
       entry,
       storageEntry
-    } = params;
+    } = transformer.transformEntryKeys();
+    const isPublished = entry.status === "published";
+    const locked = isPublished ? true : entry.locked;
     const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createRevisionSortKey)(entry)
     };
     const latestKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createLatestSortKey)()
     };
+    const publishedKeys = {
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
+      SK: (0, _keys.createPublishedSortKey)()
+    };
+
     /**
      * We need the latest entry to check if it needs to be updated.
      */
-
     const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
       model,
-      ids: [originalEntry.id]
+      ids: [entry.id]
+    });
+    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [entry.id]
+    });
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        locked,
+        ...revisionKeys,
+        TYPE: (0, _recordType.createRecordType)()
+      }]
+    });
+    if (isPublished) {
+      entityBatch.put({
+        ...storageEntry,
+        locked,
+        ...publishedKeys,
+        TYPE: (0, _recordType.createPublishedRecordType)()
+      });
+    }
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity
+    });
+    const {
+      index: esIndex
+    } = _configurations.configurations.es({
+      model
     });
-    const items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), revisionKeys), {}, {
-      TYPE: createType()
-    }))];
+
     /**
      * If the latest entry is the one being updated, we need to create a new latest entry records.
      */
+    if (latestStorageEntry) {
+      const updatingLatestRevision = latestStorageEntry.id === entry.id;
+      if (updatingLatestRevision) {
+        /**
+         * First we update the regular DynamoDB table.
+         */
+        entityBatch.put({
+          ...storageEntry,
+          ...latestKeys,
+          TYPE: (0, _recordType.createLatestRecordType)()
+        });
 
-    let elasticsearchLatestData = null;
+        /**
+         * And then update the Elasticsearch table to propagate changes to the Elasticsearch
+         */
+        const elasticsearchLatestData = await transformer.getElasticsearchLatestEntryData();
+        elasticsearchEntityBatch.put({
+          ...latestKeys,
+          index: esIndex,
+          data: elasticsearchLatestData
+        });
+      } else {
+        /**
+         * If not updating latest revision, we still want to update the latest revision's
+         * entry-level meta fields to match the current revision's entry-level meta fields.
+         */
+        const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
+        const updatedLatestStorageEntry = {
+          ...latestStorageEntry,
+          ...latestKeys,
+          ...updatedEntryLevelMetaFields
+        };
 
-    if (latestStorageEntry.id === originalEntry.id) {
-      /**
-       * First we update the regular DynamoDB table
-       */
-      items.push(entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), latestKeys), {}, {
-        TYPE: (0, _keys.createLatestSortKey)()
-      })));
-      /**
-       * And then update the Elasticsearch table to propagate changes to the Elasticsearch
-       */
+        /**
+         * First we update the regular DynamoDB table. Two updates are needed:
+         * - one for the actual revision record
+         * - one for the latest record
+         */
+        entityBatch.put({
+          ...updatedLatestStorageEntry,
+          PK: (0, _keys.createPartitionKey)({
+            id: latestStorageEntry.id,
+            locale: model.locale,
+            tenant: model.tenant
+          }),
+          SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
+          TYPE: (0, _recordType.createRecordType)()
+        });
+        entityBatch.put({
+          ...updatedLatestStorageEntry,
+          TYPE: (0, _recordType.createLatestRecordType)()
+        });
 
-      const esEntry = (0, _helpers.prepareEntryToIndex)({
-        plugins,
-        model,
-        entry: (0, _lodash.default)(entry),
-        storageEntry: (0, _lodash.default)(storageEntry)
+        /**
+         * Update the Elasticsearch table to propagate changes to the Elasticsearch.
+         */
+        const latestEsEntry = await (0, _dbDynamodb.getClean)({
+          entity: esEntity,
+          keys: latestKeys
+        });
+        if (latestEsEntry) {
+          const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
+          const updatedLatestEntry = await (0, _apiElasticsearch.compress)(plugins, {
+            ...latestEsEntryDataDecompressed,
+            ...updatedEntryLevelMetaFields
+          });
+          elasticsearchEntityBatch.put({
+            ...latestKeys,
+            index: esIndex,
+            data: updatedLatestEntry
+          });
+        }
+      }
+    }
+    if (isPublished && publishedStorageEntry?.id === entry.id) {
+      const elasticsearchPublishedData = await transformer.getElasticsearchPublishedEntryData();
+      elasticsearchEntityBatch.put({
+        ...publishedKeys,
+        index: esIndex,
+        data: elasticsearchPublishedData
       });
-      elasticsearchLatestData = await getESLatestEntryData(plugins, esEntry);
     }
-
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
       throw new _error.default(ex.message || "Could not update entry DynamoDB records.", ex.code || "UPDATE_ENTRY_ERROR", {
         error: ex,
-        originalEntry,
         entry,
         storageEntry
       });
     }
-
-    if (!elasticsearchLatestData) {
-      return storageEntry;
-    }
-
-    const {
-      index: esIndex
-    } = _configurations.default.es({
-      model
-    });
-
     try {
-      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
-        index: esIndex,
-        data: elasticsearchLatestData
-      }));
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not update entry DynamoDB Elasticsearch record.", ex.code || "UPDATE_ES_ENTRY_ERROR", {
+      throw new _error.default(ex.message || "Could not update entry DynamoDB Elasticsearch records.", ex.code || "UPDATE_ES_ENTRY_ERROR", {
         error: ex,
-        originalEntry,
         entry
       });
     }
-
-    return storageEntry;
+    return initialStorageEntry;
   };
-
-  const deleteEntry = async (model, params) => {
-    const {
-      entry
-    } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
-    const items = await (0, _query.queryAll)({
-      entity,
-      partitionKey,
-      options: {
-        gte: " "
-      }
+  const move = async (initialModel, id, folderId) => {
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id,
+      locale: model.locale,
+      tenant: model.tenant
     });
-    const esItems = await (0, _query.queryAll)({
-      entity: esEntity,
+    /**
+     * First we need to fetch all the records in the regular DynamoDB table.
+     */
+    const queryAllParams = {
+      entity,
       partitionKey,
       options: {
         gte: " "
       }
+    };
+    const latestSortKey = (0, _keys.createLatestSortKey)();
+    const publishedSortKey = (0, _keys.createPublishedSortKey)();
+    const records = await (0, _dbDynamodb.queryAll)(queryAllParams);
+    /**
+     * Then update the folderId in each record and prepare it to be stored.
+     */
+    let latestRecord = undefined;
+    let publishedRecord = undefined;
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity
     });
-    const deleteItems = items.map(item => {
-      return entity.deleteBatch({
-        PK: item.PK,
-        SK: item.SK
-      });
-    });
-    const deleteEsItems = esItems.map(item => {
-      return esEntity.deleteBatch({
-        PK: item.PK,
-        SK: item.SK
+    for (const record of records) {
+      entityBatch.put({
+        ...record,
+        location: {
+          ...record?.location,
+          folderId
+        }
       });
-    });
 
+      /**
+       * We need to get the published and latest records, so we can update the Elasticsearch.
+       */
+      if (record.SK === publishedSortKey) {
+        publishedRecord = record;
+      } else if (record.SK === latestSortKey) {
+        latestRecord = record;
+      }
+    }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items: deleteItems
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not delete entry records from DynamoDB table.", ex.code || "DELETE_ENTRY_ERROR", {
+      throw new _error.default(ex.message || "Could not move all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_ERROR", {
         error: ex,
-        entry
+        id
       });
     }
-
+    const esGetItems = [];
+    if (publishedRecord) {
+      esGetItems.push(esEntity.getBatch({
+        PK: partitionKey,
+        SK: publishedSortKey
+      }));
+    }
+    if (latestRecord) {
+      esGetItems.push(esEntity.getBatch({
+        PK: partitionKey,
+        SK: latestSortKey
+      }));
+    }
+    if (esGetItems.length === 0) {
+      return;
+    }
+    const esRecords = await (0, _dbDynamodb.batchReadAll)({
+      table: esEntity.table,
+      items: esGetItems
+    });
+    const esItems = (await Promise.all(esRecords.map(async record => {
+      if (!record) {
+        return null;
+      }
+      return {
+        ...record,
+        data: await (0, _apiElasticsearch.decompress)(plugins, record.data)
+      };
+    }))).filter(Boolean);
+    if (esItems.length === 0) {
+      return;
+    }
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity,
+      put: await Promise.all(esItems.map(async item => {
+        return {
+          ...item,
+          data: await (0, _apiElasticsearch.compress)(plugins, {
+            ...item.data,
+            location: {
+              ...item.data?.location,
+              folderId
+            }
+          })
+        };
+      }))
+    });
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: deleteEsItems
-      });
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not delete entry records from DynamoDB Elasticsearch table.", ex.code || "DELETE_ENTRY_ERROR", {
+      throw new _error.default(ex.message || "Could not move entry DynamoDB Elasticsearch records.", ex.code || "MOVE_ES_ENTRY_ERROR", {
         error: ex,
-        entry
+        partitionKey
       });
     }
   };
-
-  const deleteRevision = async (model, params) => {
+  const moveToBin = async (initialModel, params) => {
     const {
-      entryToDelete,
-      entryToSetAsLatest,
-      storageEntryToSetAsLatest
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
     } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(entryToDelete);
-
+    const model = getStorageOperationsModel(initialModel);
+    const transformer = (0, _transformations.createTransformer)({
+      plugins,
+      model,
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    });
     const {
-      index
-    } = _configurations.default.es({
-      model
+      entry,
+      storageEntry
+    } = transformer.transformEntryKeys();
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
     });
+
     /**
-     * We need published entry to delete it if necessary.
+     * First we need to fetch all the records in the regular DynamoDB table.
      */
+    const queryAllParams = {
+      entity,
+      partitionKey,
+      options: {
+        gte: " "
+      }
+    };
+    const latestSortKey = (0, _keys.createLatestSortKey)();
+    const publishedSortKey = (0, _keys.createPublishedSortKey)();
+    const records = await (0, _dbDynamodb.queryAll)(queryAllParams);
 
-
-    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
-      model,
-      ids: [entryToDelete.id]
-    });
     /**
-     * We need to delete all existing records of the given entry revision.
+     * Let's pick the `deleted` meta fields from the entry.
      */
+    const updatedEntryMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isDeletedEntryMetaField);
 
-    const items = [
     /**
-     * Delete records of given entry revision.
+     * Then update all the records with data received.
      */
-    entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entryToDelete)
-    })];
-    const esItems = [];
+    let latestRecord = undefined;
+    let publishedRecord = undefined;
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity
+    });
+    for (const record of records) {
+      entityBatch.put({
+        ...record,
+        ...updatedEntryMetaFields,
+        wbyDeleted: storageEntry.wbyDeleted,
+        location: storageEntry.location,
+        binOriginalFolderId: storageEntry.binOriginalFolderId
+      });
+
+      /**
+       * We need to get the published and latest records, so we can update the Elasticsearch.
+       */
+      if (record.SK === publishedSortKey) {
+        publishedRecord = record;
+      } else if (record.SK === latestSortKey) {
+        latestRecord = record;
+      }
+    }
+
     /**
-     * If revision we are deleting is the published one as well, we need to delete those records as well.
+     * We write the records back to the primary DynamoDB table.
      */
-
-    if (publishedStorageEntry && entryToDelete.id === publishedStorageEntry.id) {
-      items.push(entity.deleteBatch({
-        PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
+    try {
+      await entityBatch.execute();
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could mark as deleted all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
+        error: ex,
+        entry,
+        storageEntry
+      });
+    }
+
+    /**
+     * We need to get the published and latest records from Elasticsearch.
+     */
+    const esGetItems = [];
+    if (publishedRecord) {
+      esGetItems.push(esEntity.getBatch({
+        PK: partitionKey,
+        SK: publishedSortKey
       }));
-      esItems.push(entity.deleteBatch({
+    }
+    if (latestRecord) {
+      esGetItems.push(esEntity.getBatch({
         PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
+        SK: latestSortKey
       }));
     }
+    if (esGetItems.length === 0) {
+      return;
+    }
+    const esRecords = await (0, _dbDynamodb.batchReadAll)({
+      table: esEntity.table,
+      items: esGetItems
+    });
+    const esItems = (await Promise.all(esRecords.map(async record => {
+      if (!record) {
+        return null;
+      }
+      return {
+        ...record,
+        data: await (0, _apiElasticsearch.decompress)(plugins, record.data)
+      };
+    }))).filter(Boolean);
+    if (esItems.length === 0) {
+      return;
+    }
 
-    if (entryToSetAsLatest) {
-      const esEntry = (0, _helpers.prepareEntryToIndex)({
-        plugins,
-        model,
-        entry: (0, _lodash.default)(entryToSetAsLatest),
-        storageEntry: (0, _lodash.default)(storageEntryToSetAsLatest)
+    /**
+     * We update all ES records with data received.
+     */
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity
+    });
+    for (const item of esItems) {
+      elasticsearchEntityBatch.put({
+        ...item,
+        data: await (0, _apiElasticsearch.compress)(plugins, {
+          ...item.data,
+          ...updatedEntryMetaFields,
+          wbyDeleted: entry.wbyDeleted,
+          location: entry.location,
+          binOriginalFolderId: entry.binOriginalFolderId
+        })
+      });
+    }
+
+    /**
+     * We write the records back to the primary DynamoDB Elasticsearch table.
+     */
+    try {
+      await elasticsearchEntityBatch.execute();
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not mark as deleted entry records from DynamoDB Elasticsearch table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
+        error: ex,
+        entry,
+        storageEntry
       });
-      const esLatestData = await getESLatestEntryData(plugins, esEntry);
+    }
+  };
+  const restoreFromBin = async (initialModel, params) => {
+    const {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const model = getStorageOperationsModel(initialModel);
+    const transformer = (0, _transformations.createTransformer)({
+      plugins,
+      model,
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    });
+    const {
+      entry,
+      storageEntry
+    } = transformer.transformEntryKeys();
+
+    /**
+     * Let's pick the `restored` meta fields from the storage entry.
+     */
+    const updatedEntryMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isRestoredEntryMetaField);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+
+    /**
+     * First we need to fetch all the records in the regular DynamoDB table.
+     */
+    const queryAllParams = {
+      entity,
+      partitionKey,
+      options: {
+        gte: " "
+      }
+    };
+    const latestSortKey = (0, _keys.createLatestSortKey)();
+    const publishedSortKey = (0, _keys.createPublishedSortKey)();
+    const records = await (0, _dbDynamodb.queryAll)(queryAllParams);
+
+    /**
+     * Then update all the records with data received.
+     */
+    let latestRecord = undefined;
+    let publishedRecord = undefined;
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity
+    });
+    for (const record of records) {
+      entityBatch.put({
+        ...record,
+        ...updatedEntryMetaFields,
+        wbyDeleted: storageEntry.wbyDeleted,
+        location: storageEntry.location,
+        binOriginalFolderId: storageEntry.binOriginalFolderId
+      });
+
       /**
-       * In the end we need to set the new latest entry
+       * We need to get the published and latest records, so we can update the Elasticsearch.
        */
+      if (record.SK === publishedSortKey) {
+        publishedRecord = record;
+      } else if (record.SK === latestSortKey) {
+        latestRecord = record;
+      }
+    }
+
+    /**
+     * We write the records back to the primary DynamoDB table.
+     */
+    try {
+      await entityBatch.execute();
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not restore all entry records from in the DynamoDB table.", ex.code || "RESTORE_ENTRY_ERROR", {
+        error: ex,
+        entry,
+        storageEntry
+      });
+    }
 
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntryToSetAsLatest), {}, {
+    /**
+     * We need to get the published and latest records from Elasticsearch.
+     */
+    const esGetItems = [];
+    if (publishedRecord) {
+      esGetItems.push(esEntity.getBatch({
         PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: createLatestType()
-      })));
-      esItems.push(esEntity.putBatch({
+        SK: publishedSortKey
+      }));
+    }
+    if (latestRecord) {
+      esGetItems.push(esEntity.getBatch({
         PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        index,
-        data: esLatestData
+        SK: latestSortKey
       }));
     }
+    const esRecords = await (0, _dbDynamodb.batchReadAll)({
+      table: esEntity.table,
+      items: esGetItems
+    });
+    const esItems = (await Promise.all(esRecords.map(async record => {
+      if (!record) {
+        return null;
+      }
+      return {
+        ...record,
+        data: await (0, _apiElasticsearch.decompress)(plugins, record.data)
+      };
+    }))).filter(Boolean);
+    if (esItems.length === 0) {
+      return initialStorageEntry;
+    }
 
+    /**
+     * We update all ES records with data received.
+     */
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity
+    });
+    for (const item of esItems) {
+      elasticsearchEntityBatch.put({
+        ...item,
+        data: await (0, _apiElasticsearch.compress)(plugins, {
+          ...item.data,
+          ...updatedEntryMetaFields,
+          wbyDeleted: entry.wbyDeleted,
+          location: entry.location,
+          binOriginalFolderId: entry.binOriginalFolderId
+        })
+      });
+    }
+
+    /**
+     * We write the records back to the primary DynamoDB Elasticsearch table.
+     */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
+      await elasticsearchEntityBatch.execute();
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not restore entry records from DynamoDB Elasticsearch table.", ex.code || "RESTORE_ENTRY_ERROR", {
+        error: ex,
+        entry,
+        storageEntry
       });
+    }
+    return initialStorageEntry;
+  };
+  const deleteEntry = async (initialModel, params) => {
+    const {
+      entry
+    } = params;
+    const id = entry.id || entry.entryId;
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const items = await (0, _dbDynamodb.queryAll)({
+      entity,
+      partitionKey,
+      options: {
+        gte: " "
+      }
+    });
+    const esItems = await (0, _dbDynamodb.queryAll)({
+      entity: esEntity,
+      partitionKey,
+      options: {
+        gte: " "
+      }
+    });
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      delete: items.map(item => {
+        return {
+          PK: item.PK,
+          SK: item.SK
+        };
+      })
+    });
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity,
+      delete: esItems.map(item => {
+        return {
+          PK: item.PK,
+          SK: item.SK
+        };
+      })
+    });
+    try {
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not batch write entry records to DynamoDB table.", ex.code || "DELETE_REVISION_ERROR", {
+      throw new _error.default(ex.message || "Could not destroy entry records from DynamoDB table.", ex.code || "DELETE_ENTRY_ERROR", {
+        error: ex,
+        id
+      });
+    }
+    try {
+      await elasticsearchEntityBatch.execute();
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not destroy entry records from DynamoDB Elasticsearch table.", ex.code || "DELETE_ENTRY_ERROR", {
         error: ex,
-        entryToDelete,
-        entryToSetAsLatest,
-        storageEntryToSetAsLatest
+        id
       });
     }
+  };
+  const deleteRevision = async (initialModel, params) => {
+    const {
+      entry,
+      latestEntry,
+      latestStorageEntry: initialLatestStorageEntry
+    } = params;
+    const model = getStorageOperationsModel(initialModel);
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const {
+      index
+    } = _configurations.configurations.es({
+      model
+    });
+    /**
+     * We need published entry to delete it if necessary.
+     */
+    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [entry.id]
+    });
+    /**
+     * We need to delete all existing records of the given entry revision.
+     */
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      delete: [{
+        PK: partitionKey,
+        SK: (0, _keys.createRevisionSortKey)(entry)
+      }]
+    });
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity
+    });
 
-    if (esItems.length === 0) {
-      return;
+    /**
+     * If revision we are deleting is the published one as well, we need to delete those records as well.
+     */
+    if (publishedStorageEntry?.id === entry.id) {
+      entityBatch.delete({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      });
+      elasticsearchEntityBatch.delete({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      });
     }
+    if (latestEntry && initialLatestStorageEntry) {
+      const latestStorageEntry = convertToStorageEntry({
+        storageEntry: initialLatestStorageEntry,
+        model
+      });
+
+      /**
+       * In the end we need to set the new latest entry.
+       */
+      entityBatch.put({
+        ...latestStorageEntry,
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: (0, _recordType.createLatestRecordType)()
+      });
 
+      /**
+       * Also perform an update on the actual revision. This is needed
+       * because of updates on the entry-level meta fields.
+       */
+      entityBatch.put({
+        ...latestStorageEntry,
+        PK: (0, _keys.createPartitionKey)({
+          id: initialLatestStorageEntry.id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: (0, _keys.createRevisionSortKey)(initialLatestStorageEntry),
+        TYPE: (0, _recordType.createRecordType)()
+      });
+      const latestTransformer = (0, _transformations.createTransformer)({
+        plugins,
+        model,
+        entry: latestEntry,
+        storageEntry: initialLatestStorageEntry
+      });
+      const esLatestData = await latestTransformer.getElasticsearchLatestEntryData();
+      elasticsearchEntityBatch.put({
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        index,
+        data: esLatestData
+      });
+    }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
+      await entityBatch.execute();
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not batch write entry records to DynamoDB table.", ex.code || "DELETE_REVISION_ERROR", {
+        error: ex,
+        entry,
+        latestEntry,
+        initialLatestStorageEntry
       });
+    }
+    try {
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
       throw new _error.default(ex.message || "Could not batch write entry records to DynamoDB Elasticsearch table.", ex.code || "DELETE_REVISION_ERROR", {
         error: ex,
-        entryToDelete,
-        entryToSetAsLatest,
-        storageEntryToSetAsLatest
+        entry,
+        latestEntry,
+        initialLatestStorageEntry
       });
     }
   };
-
-  const list = async (model, params) => {
-    const limit = (0, _limit.createLimit)(params.limit, 50);
-    const body = (0, _helpers.createElasticsearchQueryBody)({
+  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,
-      args: _objectSpread(_objectSpread({}, params), {}, {
-        limit
-      }),
-      plugins,
-      parentPath: "values"
+      ids: entries
     });
-    let response;
+    /**
+     * Then we need to construct the queries for all the revisions and entries.
+     */
+
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity
+    });
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity
+    });
+    for (const id of entries) {
+      /**
+       * Latest item.
+       */
+      entityBatch.delete({
+        PK: (0, _keys.createPartitionKey)({
+          id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: "L"
+      });
+      elasticsearchEntityBatch.delete({
+        PK: (0, _keys.createPartitionKey)({
+          id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: "L"
+      });
 
+      /**
+       * Published item.
+       */
+      entityBatch.delete({
+        PK: (0, _keys.createPartitionKey)({
+          id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: "P"
+      });
+      elasticsearchEntityBatch.delete({
+        PK: (0, _keys.createPartitionKey)({
+          id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: "P"
+      });
+    }
+    /**
+     * Exact revisions of all the entries
+     */
+    for (const revision of revisions) {
+      entityBatch.delete({
+        PK: (0, _keys.createPartitionKey)({
+          id: revision.id,
+          locale: model.locale,
+          tenant: model.tenant
+        }),
+        SK: (0, _keys.createRevisionSortKey)({
+          version: revision.version
+        })
+      });
+    }
+    await entityBatch.execute();
+    await elasticsearchEntityBatch.execute();
+  };
+  const list = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const limit = (0, _apiElasticsearch.createLimit)(params.limit, 50);
     const {
       index
-    } = _configurations.default.es({
+    } = _configurations.configurations.es({
       model
     });
-
+    const body = (0, _body.createElasticsearchBody)({
+      model,
+      params: {
+        ...params,
+        limit,
+        after: (0, _apiElasticsearch.decodeCursor)(params.after)
+      },
+      plugins
+    });
+    let response;
     try {
       response = await elasticsearch.search({
         index,
         body
       });
-    } catch (ex) {
-      throw new _error.default(ex.message, ex.code || "ELASTICSEARCH_ERROR", {
-        error: ex,
+    } catch (error) {
+      /**
+       * We will silently ignore the `index_not_found_exception` error and return an empty result set.
+       * This is because the index might not exist yet, and we don't want to throw an error.
+       */
+      if ((0, _shouldIgnoreEsResponseError.shouldIgnoreEsResponseError)(error)) {
+        (0, _logIgnoredEsResponseError.logIgnoredEsResponseError)({
+          error,
+          model,
+          indexName: index
+        });
+        return {
+          hasMoreItems: false,
+          totalCount: 0,
+          cursor: null,
+          items: []
+        };
+      }
+      throw new _error.default(error.message, error.code || "ELASTICSEARCH_ERROR", {
+        error,
         index,
-        body
+        body,
+        model
       });
     }
-
     const {
       hits,
       total
-    } = response.body.hits;
+    } = response?.body?.hits || {};
     const items = (0, _helpers.extractEntriesFromIndex)({
       plugins,
       model,
       entries: hits.map(item => item._source)
+    }).map(item => {
+      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+        model,
+        entry: item
+      });
     });
     const hasMoreItems = items.length > limit;
-
     if (hasMoreItems) {
       /**
        * Remove the last item from results, we don't want to include it.
@@ -551,9 +1236,7 @@ const createEntriesStorageOperations = params => {
      * Cursor is the `sort` value of the last item in the array.
      * https://www.elastic.co/guide/en/elasticsearch/reference/current/paginate-search-results.html#search-after
      */
-
-
-    const cursor = items.length > 0 ? (0, _cursors.encodeCursor)(hits[items.length - 1].sort) : null;
+    const cursor = items.length > 0 ? (0, _apiElasticsearch.encodeCursor)(hits[items.length - 1].sort) || null : null;
     return {
       hasMoreItems,
       totalCount: total.value,
@@ -561,158 +1244,270 @@ const createEntriesStorageOperations = params => {
       items
     };
   };
-
-  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, {
+      ...params,
       limit: 1
-    }));
-
-    if (items.length === 0) {
-      return null;
-    }
-
-    return items.shift();
+    });
+    return items.shift() || null;
   };
-
-  const publish = async (model, params) => {
+  const publish = async (initialModel, params) => {
     const {
-      entry,
-      storageEntry
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
     } = params;
-    /**
-     * We need currently published entry to check if need to remove it.
-     */
-
-    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+    const model = getStorageOperationsModel(initialModel);
+    const transformer = (0, _transformations.createTransformer)({
+      plugins,
       model,
-      ids: [entry.id]
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
     });
+    const {
+      entry,
+      storageEntry
+    } = transformer.transformEntryKeys();
     const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createRevisionSortKey)(entry)
     };
     const latestKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createLatestSortKey)()
     };
     const publishedKeys = {
-      PK: (0, _keys.createPartitionKey)(entry),
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
       SK: (0, _keys.createPublishedSortKey)()
     };
     let latestEsEntry = null;
-
     try {
-      latestEsEntry = await (0, _get.get)({
+      latestEsEntry = await (0, _dbDynamodb.getClean)({
         entity: esEntity,
         keys: latestKeys
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not read Elasticsearch latest or published data.", ex.code || "PUBLISH_BATCH_READ", {
+      throw new _error.default(ex.message || "Could not read Elasticsearch latest data.", ex.code || "PUBLISH_LATEST_READ", {
         error: ex,
         latestKeys: latestKeys,
         publishedKeys: publishedKeys
       });
     }
+    if (!latestEsEntry) {
+      throw new _error.default(`Could not publish entry. Could not load latest ("L") record (ES table).`, "PUBLISH_ERROR", {
+        entry
+      });
+    }
+
+    /**
+     * We need the latest entry to check if it needs to be updated as well in the Elasticsearch.
+     */
+    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: [entry.id]
+    });
+    if (!latestStorageEntry) {
+      throw new _error.default(`Could not publish entry. Could not load latest ("L") record.`, "PUBLISH_ERROR", {
+        entry
+      });
+    }
 
-    const items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), revisionKeys), {}, {
-      TYPE: createType()
-    }))];
-    const esItems = [];
+    /**
+     * We need currently published entry to check if need to remove it.
+     */
+    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [entry.id]
+    });
 
+    // 1. Update REV# and P records with new data.
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        ...revisionKeys,
+        TYPE: (0, _recordType.createRecordType)()
+      }, {
+        ...storageEntry,
+        ...publishedKeys,
+        TYPE: (0, _recordType.createPublishedRecordType)()
+      }]
+    });
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity
+    });
     const {
-      index
-    } = _configurations.default.es({
+      index: esIndex
+    } = _configurations.configurations.es({
       model
     });
 
-    if (publishedStorageEntry) {
-      /**
-       * If there is a `published` entry already, we need to set it to `unpublished`. We need to
-       * execute two updates: update the previously published entry's status and the published entry record.
-       * DynamoDB does not support `batchUpdate` - so here we load the previously published
-       * entry's data to update its status within a batch operation. If, hopefully,
-       * they introduce a true update batch operation, remove this `read` call.
-       */
-      const [previouslyPublishedEntry] = await dataLoaders.getRevisionById({
-        model,
-        ids: [publishedStorageEntry.id]
+    // 2. When it comes to the latest record, we need to perform a couple of different
+    // updates, based on whether the entry being published is the latest revision or not.
+    const publishedRevisionId = publishedStorageEntry?.id;
+    const publishingLatestRevision = latestStorageEntry?.id === entry.id;
+    if (publishingLatestRevision) {
+      // 2.1 If we're publishing the latest revision, we first need to update the L record.
+      entityBatch.put({
+        ...storageEntry,
+        ...latestKeys
       });
-      items.push(
-      /**
-       * Update currently published entry (unpublish it)
-       */
-      entity.putBatch(_objectSpread(_objectSpread({}, previouslyPublishedEntry), {}, {
-        status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
-        savedOn: entry.savedOn,
-        TYPE: createType(),
-        PK: (0, _keys.createPartitionKey)(publishedStorageEntry),
-        SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry)
-      })));
+
+      // 2.2 Additionally, if we have a previously published entry, we need to mark it as unpublished.
+      //     Note that we need to take re-publishing into account (same published revision being
+      //     published again), in which case the below code does not apply. This is because the
+      //     required updates were already applied above.
+      if (publishedStorageEntry) {
+        const isRepublishing = publishedStorageEntry.id === entry.id;
+        if (!isRepublishing) {
+          /**
+           * Update currently published entry (unpublish it)
+           */
+          entityBatch.put({
+            ...publishedStorageEntry,
+            status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
+            TYPE: (0, _recordType.createRecordType)(),
+            PK: (0, _keys.createPartitionKey)(publishedStorageEntry),
+            SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry)
+          });
+        }
+      }
+    } else {
+      // 2.3 If the published revision is not the latest one, the situation is a bit
+      // more complex. We first need to update the L and REV# records with the new
+      // values of *only entry-level* meta fields.
+      const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
+
+      // 2.4 Update L record. Apart from updating the entry-level meta fields, we also need
+      //    to change the status from "published" to "unpublished" (if the status is set to "published").
+      let latestRevisionStatus = latestStorageEntry.status;
+      if (latestRevisionStatus === _types.CONTENT_ENTRY_STATUS.PUBLISHED) {
+        latestRevisionStatus = _types.CONTENT_ENTRY_STATUS.UNPUBLISHED;
+      }
+      const latestStorageEntryFields = {
+        ...latestStorageEntry,
+        ...updatedEntryLevelMetaFields,
+        status: latestRevisionStatus
+      };
+      entityBatch.put({
+        ...latestStorageEntryFields,
+        PK: (0, _keys.createPartitionKey)(latestStorageEntry),
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: (0, _recordType.createLatestRecordType)()
+      });
+
+      // 2.5 Update REV# record.
+      entityBatch.put({
+        ...latestStorageEntryFields,
+        PK: (0, _keys.createPartitionKey)(latestStorageEntry),
+        SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
+        TYPE: (0, _recordType.createRecordType)()
+      });
+
+      // 2.6 Additionally, if we have a previously published entry, we need to mark it as unpublished.
+      //     Note that we need to take re-publishing into account (same published revision being
+      //     published again), in which case the below code does not apply. This is because the
+      //     required updates were already applied above.
+      if (publishedStorageEntry) {
+        const isRepublishing = publishedStorageEntry.id === entry.id;
+        const publishedRevisionDifferentFromLatest = publishedRevisionId !== latestStorageEntry.id;
+        if (!isRepublishing && publishedRevisionDifferentFromLatest) {
+          entityBatch.put({
+            ...publishedStorageEntry,
+            PK: (0, _keys.createPartitionKey)(publishedStorageEntry),
+            SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry),
+            TYPE: (0, _recordType.createRecordType)(),
+            status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED
+          });
+        }
+      }
     }
-    /**
-     * Update the helper item in DB with the new published entry
-     */
 
+    // 3. Update records in ES -> DDB table.
 
-    items.push(entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), publishedKeys), {}, {
-      TYPE: createPublishedType()
-    })));
     /**
-     * We need the latest entry to check if it neds to be updated as well in the Elasticsearch.
+     * Update the published revision entry in ES.
      */
-
-    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
-      model,
-      ids: [entry.id]
+    const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
+    elasticsearchEntityBatch.put({
+      ...publishedKeys,
+      index: esIndex,
+      data: esPublishedData
     });
+
     /**
-     * If we are publishing the latest revision, let's also update the latest revision's status in ES.
+     * Need to decompress the data from Elasticsearch DynamoDB table.
+     *
+     * No need to transform it for the storage because it was fetched
+     * directly from the Elasticsearch table, where it sits transformed.
      */
+    const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
+    if (publishingLatestRevision) {
+      const updatedMetaFields = (0, _constants.pickEntryMetaFields)(entry);
+      const latestTransformer = (0, _transformations.createTransformer)({
+        plugins,
+        model,
+        transformedToIndex: {
+          ...latestEsEntryDataDecompressed,
+          status: _types.CONTENT_ENTRY_STATUS.PUBLISHED,
+          locked: true,
+          ...updatedMetaFields
+        }
+      });
+      elasticsearchEntityBatch.put({
+        index: esIndex,
+        PK: (0, _keys.createPartitionKey)(latestEsEntryDataDecompressed),
+        SK: (0, _keys.createLatestSortKey)(),
+        data: await latestTransformer.getElasticsearchLatestEntryData()
+      });
+    } else {
+      const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
 
-    if (latestStorageEntry && latestStorageEntry.id === entry.id) {
       /**
-       * Need to decompress the data from Elasticsearch DynamoDB table.
+       * Update the Elasticsearch table to propagate changes to the Elasticsearch.
        */
-      const latestEsEntryDataDecompressed = await (0, _compression.decompress)(plugins, latestEsEntry.data);
-      esItems.push(esEntity.putBatch({
-        index,
-        PK: (0, _keys.createPartitionKey)(latestEsEntryDataDecompressed),
-        SK: (0, _keys.createLatestSortKey)(),
-        data: _objectSpread(_objectSpread({}, latestEsEntryDataDecompressed), {}, {
-          status: _types.CONTENT_ENTRY_STATUS.PUBLISHED,
-          locked: true,
-          savedOn: entry.savedOn,
-          publishedOn: entry.publishedOn
-        })
-      }));
+      const latestEsEntry = await (0, _dbDynamodb.getClean)({
+        entity: esEntity,
+        keys: latestKeys
+      });
+      if (latestEsEntry) {
+        const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
+        let latestRevisionStatus = latestEsEntryDataDecompressed.status;
+        if (latestRevisionStatus === _types.CONTENT_ENTRY_STATUS.PUBLISHED) {
+          latestRevisionStatus = _types.CONTENT_ENTRY_STATUS.UNPUBLISHED;
+        }
+        const updatedLatestEntry = await (0, _apiElasticsearch.compress)(plugins, {
+          ...latestEsEntryDataDecompressed,
+          ...updatedEntryLevelMetaFields,
+          status: latestRevisionStatus
+        });
+        elasticsearchEntityBatch.put({
+          ...latestKeys,
+          index: esIndex,
+          data: updatedLatestEntry
+        });
+      }
     }
 
-    const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
-      plugins,
-      model,
-      entry: (0, _lodash.default)(entry),
-      storageEntry: (0, _lodash.default)(storageEntry)
-    });
-    /**
-     * Update the published revision entry in ES.
-     */
-
-    const esLatestData = await getESPublishedEntryData(plugins, preparedEntryData);
-    esItems.push(esEntity.putBatch(_objectSpread(_objectSpread({}, publishedKeys), {}, {
-      index,
-      data: esLatestData
-    })));
     /**
      * Finally, execute regular table batch.
      */
-
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
@@ -727,13 +1522,8 @@ const createEntriesStorageOperations = params => {
     /**
      * And Elasticsearch table batch.
      */
-
-
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
       throw new _error.default(ex.message || "Could not store publish entry records in DynamoDB Elasticsearch table.", ex.code || "PUBLISH_ES_ERROR", {
         error: ex,
@@ -742,71 +1532,87 @@ const createEntriesStorageOperations = params => {
         publishedStorageEntry
       });
     }
-
-    return storageEntry;
+    return initialStorageEntry;
   };
-
-  const unpublish = async (model, params) => {
+  const unpublish = async (initialModel, params) => {
+    const {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const model = getStorageOperationsModel(initialModel);
+    const transformer = (0, _transformations.createTransformer)({
+      plugins,
+      model,
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    });
     const {
       entry,
       storageEntry
-    } = params;
+    } = await transformer.transformEntryKeys();
+
     /**
      * We need the latest entry to check if it needs to be updated.
      */
-
     const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
       model,
       ids: [entry.id]
     });
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
-    const items = [entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createPublishedSortKey)()
-    }), entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      TYPE: createType()
-    }))];
-    const esItems = [esEntity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createPublishedSortKey)()
-    })];
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        PK: partitionKey,
+        SK: (0, _keys.createRevisionSortKey)(entry),
+        TYPE: (0, _recordType.createRecordType)()
+      }],
+      delete: [{
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }]
+    });
+    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity: esEntity,
+      delete: [{
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }]
+    });
+
     /**
-     * If we are unpublishing the latest revision, let's also update the latest revision entry's status in ES.
+     * If we are unpublishing the latest revision, let's also update the latest revision entry's status in both DynamoDB tables.
      */
-
-    if (latestStorageEntry.id === entry.id) {
+    if (latestStorageEntry?.id === entry.id) {
       const {
         index
-      } = _configurations.default.es({
+      } = _configurations.configurations.es({
         model
       });
-
-      const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
-        plugins,
-        model,
-        entry: (0, _lodash.default)(entry),
-        storageEntry: (0, _lodash.default)(storageEntry)
+      entityBatch.put({
+        ...storageEntry,
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: (0, _recordType.createLatestRecordType)()
       });
-      const esLatestData = await getESLatestEntryData(plugins, preparedEntryData);
-      esItems.push(esEntity.putBatch({
+      const esLatestData = await transformer.getElasticsearchLatestEntryData();
+      elasticsearchEntityBatch.put({
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
         index,
         data: esLatestData
-      }));
+      });
     }
+
     /**
      * Finally, execute regular table batch.
      */
-
-
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
@@ -819,267 +1625,112 @@ const createEntriesStorageOperations = params => {
     /**
      * And Elasticsearch table batch.
      */
-
-
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
       throw new _error.default(ex.message || "Could not store unpublished entry records in DynamoDB Elasticsearch table.", ex.code || "UNPUBLISH_ERROR", {
         entry,
         storageEntry
       });
     }
-
-    return storageEntry;
-  };
-
-  const requestReview = async (model, params) => {
-    const {
-      entry,
-      storageEntry,
-      originalEntry
-    } = params;
-    /**
-     * We need the latest entry to check if it needs to be updated.
-     */
-
-    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
-      model,
-      ids: [entry.id]
-    });
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
-    /**
-     * If we updated the latest version, then make sure the changes are propagated to ES too.
-     */
-
-    let esLatestData = null;
-
-    const {
-      index
-    } = _configurations.default.es({
-      model
-    });
-
-    if (latestStorageEntry && latestStorageEntry.id === entry.id) {
-      const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
-        plugins,
-        model,
-        entry: (0, _lodash.default)(entry),
-        storageEntry: (0, _lodash.default)(storageEntry)
-      });
-      esLatestData = await getESLatestEntryData(plugins, preparedEntryData);
-    }
-
-    try {
-      await entity.put(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: (0, _keys.createRevisionSortKey)(entry),
-        TYPE: createType()
-      }));
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not store request review entry record into DynamoDB table.", ex.code || "REQUEST_REVIEW_ERROR", {
-        entry,
-        latestStorageEntry,
-        originalEntry
-      });
-    }
-    /**
-     * No need to proceed further if nothing to put into Elasticsearch.
-     */
-
-
-    if (!esLatestData) {
-      return storageEntry;
-    }
-
-    try {
-      await esEntity.put({
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        index,
-        data: esLatestData
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not store request review entry record into DynamoDB Elasticsearch table.", ex.code || "REQUEST_REVIEW_ERROR", {
-        entry,
-        latestStorageEntry,
-        originalEntry
-      });
-    }
-
-    return storageEntry;
+    return initialStorageEntry;
   };
-
-  const requestChanges = async (model, params) => {
-    const {
-      entry,
-      storageEntry,
-      originalEntry
-    } = params;
-    /**
-     * We need the latest entry to check if it needs to be updated.
-     */
-
-    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
+  const getLatestRevisionByEntryId = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const [entry] = await dataLoaders.getLatestRevisionByEntryId({
       model,
-      ids: [entry.id]
-    });
-    const partitionKey = (0, _keys.createPartitionKey)(entry);
-    const items = [entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      TYPE: createType()
-    }))];
-    /**
-     * If we updated the latest version, then make sure the changes are propagated to ES too.
-     */
-
-    const {
-      index
-    } = _configurations.default.es({
-      model
+      ids: [params.id]
     });
-
-    let esLatestData = null;
-
-    if (latestStorageEntry && latestStorageEntry.id === entry.id) {
-      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: createLatestType()
-      })));
-      const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
-        plugins,
-        model,
-        entry: (0, _lodash.default)(entry),
-        storageEntry: (0, _lodash.default)(storageEntry)
-      });
-      esLatestData = await getESLatestEntryData(plugins, preparedEntryData);
-    }
-
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
-      dataLoaders.clearAll({
-        model
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not store request changes entry record into DynamoDB table.", ex.code || "REQUEST_CHANGES_ERROR", {
-        entry,
-        latestStorageEntry,
-        originalEntry
-      });
-    }
-    /**
-     * No need to proceed further if nothing to put into Elasticsearch.
-     */
-
-
-    if (!esLatestData) {
-      return storageEntry;
-    }
-
-    try {
-      await esEntity.put({
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        index,
-        data: esLatestData
-      });
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not store request changes entry record into DynamoDB Elasticsearch table.", ex.code || "REQUEST_CHANGES_ERROR", {
-        entry,
-        latestStorageEntry,
-        originalEntry
-      });
+    if (!entry) {
+      return null;
     }
-
-    return storageEntry;
-  };
-
-  const getAllRevisionsByIds = async (model, params) => {
-    return await dataLoaders.getAllEntryRevisions({
+    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
       model,
-      ids: params.ids
+      entry
     });
   };
-
-  const getLatestRevisionByEntryId = async (model, params) => {
-    const result = await dataLoaders.getLatestRevisionByEntryId({
+  const getPublishedRevisionByEntryId = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const [entry] = await dataLoaders.getPublishedRevisionByEntryId({
       model,
       ids: [params.id]
     });
-
-    if (result.length === 0) {
+    if (!entry) {
       return null;
     }
-
-    return result.shift();
-  };
-
-  const getPublishedRevisionByEntryId = async (model, params) => {
-    const result = await dataLoaders.getPublishedRevisionByEntryId({
+    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
       model,
-      ids: [params.id]
+      entry
     });
-
-    if (result.length === 0) {
-      return null;
-    }
-
-    return result.shift();
   };
-
-  const getRevisionById = async (model, params) => {
-    const result = await dataLoaders.getRevisionById({
+  const getRevisionById = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const [entry] = await dataLoaders.getRevisionById({
       model,
       ids: [params.id]
     });
-
-    if (result.length === 0) {
+    if (!entry) {
       return null;
     }
-
-    return result.shift();
+    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      model,
+      entry
+    });
   };
-
-  const getRevisions = async (model, params) => {
-    return await dataLoaders.getAllEntryRevisions({
+  const getRevisions = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const entries = await dataLoaders.getAllEntryRevisions({
       model,
       ids: [params.id]
     });
+    return entries.map(entry => {
+      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+        model,
+        entry
+      });
+    });
   };
-
-  const getByIds = async (model, params) => {
-    return dataLoaders.getRevisionById({
+  const getByIds = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const entries = await dataLoaders.getRevisionById({
       model,
       ids: params.ids
     });
+    return entries.map(entry => {
+      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+        model,
+        entry
+      });
+    });
   };
-
-  const getLatestByIds = async (model, params) => {
-    return dataLoaders.getLatestRevisionByEntryId({
+  const getLatestByIds = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const entries = await dataLoaders.getLatestRevisionByEntryId({
       model,
       ids: params.ids
     });
+    return entries.map(entry => {
+      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+        model,
+        entry
+      });
+    });
   };
-
-  const getPublishedByIds = async (model, params) => {
-    return dataLoaders.getPublishedRevisionByEntryId({
+  const getPublishedByIds = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
+    const entries = await dataLoaders.getPublishedRevisionByEntryId({
       model,
       ids: params.ids
     });
+    return entries.map(entry => {
+      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+        model,
+        entry
+      });
+    });
   };
-
-  const getPreviousRevision = async (model, params) => {
+  const getPreviousRevision = async (initialModel, params) => {
+    const model = getStorageOperationsModel(initialModel);
     const {
       tenant,
       locale
@@ -1097,13 +1748,12 @@ const createEntriesStorageOperations = params => {
       }),
       options: {
         lt: `REV#${(0, _utils.zeroPad)(version)}`,
-
         /**
          * We need to have extra checks because DynamoDB will return published or latest record if there is no REV# record.
          */
         filters: [{
           attr: "TYPE",
-          eq: createType()
+          eq: (0, _recordType.createRecordType)()
         }, {
           attr: "version",
           lt: version
@@ -1111,33 +1761,109 @@ const createEntriesStorageOperations = params => {
         reverse: true
       }
     };
-
     try {
-      const result = await (0, _query.queryOne)(queryParams);
-      return (0, _cleanup.cleanupItem)(entity, result);
+      const result = await (0, _dbDynamodb.queryOne)(queryParams);
+      const entry = (0, _dbDynamodb.cleanupItem)(entity, result);
+      if (!entry) {
+        return null;
+      }
+      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+        entry,
+        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", {
+        ...params,
         error: ex,
         partitionKey: queryParams.partitionKey,
         options: queryParams.options,
         model
-      }));
+      });
     }
   };
-
+  const getUniqueFieldValues = async (model, params) => {
+    const {
+      where,
+      fieldId
+    } = params;
+    const {
+      index
+    } = _configurations.configurations.es({
+      model
+    });
+    const initialBody = (0, _body.createElasticsearchBody)({
+      model,
+      params: {
+        limit: 1,
+        where
+      },
+      plugins
+    });
+    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 body = {
+      ...initialBody,
+      /**
+       * We do not need any hits returned, we only need the aggregations.
+       */
+      size: 0,
+      aggregations: {
+        getUniqueFieldValues: {
+          terms: {
+            field: `values.${field.storageId}.keyword`,
+            size: 1000000
+          }
+        }
+      }
+    };
+    let response = undefined;
+    try {
+      response = await elasticsearch.search({
+        index,
+        body
+      });
+    } catch (error) {
+      if ((0, _shouldIgnoreEsResponseError.shouldIgnoreEsResponseError)(error)) {
+        (0, _logIgnoredEsResponseError.logIgnoredEsResponseError)({
+          error,
+          model,
+          indexName: index
+        });
+        return [];
+      }
+      throw new _error.default(error.message || "Error in the Elasticsearch query.", error.code || "ELASTICSEARCH_ERROR", {
+        error,
+        index,
+        model,
+        body
+      });
+    }
+    const buckets = response.body.aggregations["getUniqueFieldValues"]?.buckets || [];
+    return buckets.map(file => {
+      return {
+        value: file.key,
+        count: file.doc_count
+      };
+    });
+  };
   return {
     create,
     createRevisionFrom,
     update,
+    move,
     delete: deleteEntry,
+    moveToBin,
+    restoreFromBin,
     deleteRevision,
+    deleteMultipleEntries,
     get,
     publish,
     unpublish,
-    requestReview,
-    requestChanges,
     list,
-    getAllRevisionsByIds,
     getLatestRevisionByEntryId,
     getPublishedRevisionByEntryId,
     getRevisionById,
@@ -1145,8 +1871,11 @@ const createEntriesStorageOperations = params => {
     getByIds,
     getLatestByIds,
     getPublishedByIds,
-    getPreviousRevision
+    getPreviousRevision,
+    getUniqueFieldValues,
+    dataLoaders
   };
 };
+exports.createEntriesStorageOperations = createEntriesStorageOperations;
 
-exports.createEntriesStorageOperations = createEntriesStorageOperations;
+//# sourceMappingURL=index.js.map