@webiny/api-headless-cms-ddb-es 0.0.0-mt-1

package/operations/entry/index.js

@@ -0,0 +1,1152 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPublishedType = exports.createLatestType = exports.createEntriesStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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 _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 _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()
+  });
+};
+
+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,
+    esEntity,
+    elasticsearch,
+    plugins
+  } = params;
+  const dataLoaders = new _dataLoaders.DataLoadersHandler({
+    entity
+  });
+
+  const create = async (model, params) => {
+    const {
+      entry,
+      storageEntry
+    } = params;
+    const esEntry = (0, _helpers.prepareEntryToIndex)({
+      plugins,
+      model,
+      entry: (0, _lodash.default)(entry),
+      storageEntry: (0, _lodash.default)(storageEntry)
+    });
+
+    const {
+      index: esIndex
+    } = _configurations.default.es({
+      model
+    });
+
+    const esLatestData = await getESLatestEntryData(plugins, esEntry);
+    const revisionKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    };
+    const latestKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      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
+      });
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not insert entry data into the DynamoDB table.", ex.code || "CREATE_ENTRY_ERROR", {
+        error: ex,
+        entry,
+        storageEntry
+      });
+    }
+
+    try {
+      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
+        index: esIndex,
+        data: esLatestData
+      }));
+    } 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,
+        entry,
+        esEntry
+      });
+    }
+
+    return storageEntry;
+  };
+
+  const createRevisionFrom = async (model, params) => {
+    const {
+      originalEntry,
+      entry,
+      storageEntry
+    } = params;
+    const revisionKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    };
+    const latestKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      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 {
+      index
+    } = _configurations.default.es({
+      model
+    });
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      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,
+        data: esLatestData
+      }));
+    } 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;
+  };
+
+  const update = async (model, params) => {
+    const {
+      originalEntry,
+      entry,
+      storageEntry
+    } = params;
+    const revisionKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    };
+    const latestKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      SK: (0, _keys.createLatestSortKey)()
+    };
+    /**
+     * We need the latest entry to check if it needs to be updated.
+     */
+
+    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: [originalEntry.id]
+    });
+    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.
+     */
+
+    let elasticsearchLatestData = null;
+
+    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
+       */
+
+      const esEntry = (0, _helpers.prepareEntryToIndex)({
+        plugins,
+        model,
+        entry: (0, _lodash.default)(entry),
+        storageEntry: (0, _lodash.default)(storageEntry)
+      });
+      elasticsearchLatestData = await getESLatestEntryData(plugins, esEntry);
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      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
+      }));
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update entry DynamoDB Elasticsearch record.", ex.code || "UPDATE_ES_ENTRY_ERROR", {
+        error: ex,
+        originalEntry,
+        entry
+      });
+    }
+
+    return storageEntry;
+  };
+
+  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 esItems = await (0, _query.queryAll)({
+      entity: esEntity,
+      partitionKey,
+      options: {
+        gte: " "
+      }
+    });
+    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
+      });
+    });
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items: deleteItems
+      });
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete entry records from DynamoDB table.", ex.code || "DELETE_ENTRY_ERROR", {
+        error: ex,
+        entry
+      });
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: deleteEsItems
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete entry records from DynamoDB Elasticsearch table.", ex.code || "DELETE_ENTRY_ERROR", {
+        error: ex,
+        entry
+      });
+    }
+  };
+
+  const deleteRevision = async (model, params) => {
+    const {
+      entryToDelete,
+      entryToSetAsLatest,
+      storageEntryToSetAsLatest
+    } = params;
+    const partitionKey = (0, _keys.createPartitionKey)(entryToDelete);
+
+    const {
+      index
+    } = _configurations.default.es({
+      model
+    });
+    /**
+     * We need published entry to delete it if necessary.
+     */
+
+
+    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [entryToDelete.id]
+    });
+    /**
+     * We need to delete all existing records of the given entry revision.
+     */
+
+    const items = [
+    /**
+     * Delete records of given entry revision.
+     */
+    entity.deleteBatch({
+      PK: partitionKey,
+      SK: (0, _keys.createRevisionSortKey)(entryToDelete)
+    })];
+    const esItems = [];
+    /**
+     * 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) {
+      items.push(entity.deleteBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }));
+      esItems.push(entity.deleteBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }));
+    }
+
+    if (entryToSetAsLatest) {
+      const esEntry = (0, _helpers.prepareEntryToIndex)({
+        plugins,
+        model,
+        entry: (0, _lodash.default)(entryToSetAsLatest),
+        storageEntry: (0, _lodash.default)(storageEntryToSetAsLatest)
+      });
+      const esLatestData = await getESLatestEntryData(plugins, esEntry);
+      /**
+       * In the end we need to set the new latest entry
+       */
+
+      items.push(entity.putBatch(_objectSpread(_objectSpread({}, storageEntryToSetAsLatest), {}, {
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: createLatestType()
+      })));
+      esItems.push(esEntity.putBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        index,
+        data: esLatestData
+      }));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      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,
+        entryToDelete,
+        entryToSetAsLatest,
+        storageEntryToSetAsLatest
+      });
+    }
+
+    if (esItems.length === 0) {
+      return;
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: esItems
+      });
+    } 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
+      });
+    }
+  };
+
+  const list = async (model, params) => {
+    const limit = (0, _limit.createLimit)(params.limit, 50);
+    const body = (0, _helpers.createElasticsearchQueryBody)({
+      model,
+      args: _objectSpread(_objectSpread({}, params), {}, {
+        limit
+      }),
+      plugins,
+      parentPath: "values"
+    });
+    let response;
+
+    const {
+      index
+    } = _configurations.default.es({
+      model
+    });
+
+    try {
+      response = await elasticsearch.search({
+        index,
+        body
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message, ex.code || "ELASTICSEARCH_ERROR", {
+        error: ex,
+        index,
+        body
+      });
+    }
+
+    const {
+      hits,
+      total
+    } = response.body.hits;
+    const items = (0, _helpers.extractEntriesFromIndex)({
+      plugins,
+      model,
+      entries: hits.map(item => item._source)
+    });
+    const hasMoreItems = items.length > limit;
+
+    if (hasMoreItems) {
+      /**
+       * Remove the last item from results, we don't want to include it.
+       */
+      items.pop();
+    }
+    /**
+     * 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;
+    return {
+      hasMoreItems,
+      totalCount: total.value,
+      cursor,
+      items
+    };
+  };
+
+  const get = async (model, params) => {
+    const {
+      items
+    } = await list(model, _objectSpread(_objectSpread({}, params), {}, {
+      limit: 1
+    }));
+
+    if (items.length === 0) {
+      return null;
+    }
+
+    return items.shift();
+  };
+
+  const publish = async (model, params) => {
+    const {
+      entry,
+      storageEntry
+    } = params;
+    /**
+     * We need currently published entry to check if need to remove it.
+     */
+
+    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [entry.id]
+    });
+    const revisionKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    };
+    const latestKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      SK: (0, _keys.createLatestSortKey)()
+    };
+    const publishedKeys = {
+      PK: (0, _keys.createPartitionKey)(entry),
+      SK: (0, _keys.createPublishedSortKey)()
+    };
+    let latestEsEntry = null;
+
+    try {
+      latestEsEntry = await (0, _get.get)({
+        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", {
+        error: ex,
+        latestKeys: latestKeys,
+        publishedKeys: publishedKeys
+      });
+    }
+
+    const items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), revisionKeys), {}, {
+      TYPE: createType()
+    }))];
+    const esItems = [];
+
+    const {
+      index
+    } = _configurations.default.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]
+      });
+      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)
+      })));
+    }
+    /**
+     * Update the helper item in DB with the new published entry
+     */
+
+
+    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.
+     */
+
+    const [latestStorageEntry] = await dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: [entry.id]
+    });
+    /**
+     * If we are publishing the latest revision, let's also update the latest revision's status in ES.
+     */
+
+    if (latestStorageEntry && latestStorageEntry.id === entry.id) {
+      /**
+       * Need to decompress the data from Elasticsearch DynamoDB table.
+       */
+      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 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
+      });
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not store publish entry records in DynamoDB table.", ex.code || "PUBLISH_ERROR", {
+        error: ex,
+        entry,
+        latestStorageEntry,
+        publishedStorageEntry
+      });
+    }
+    /**
+     * And Elasticsearch table batch.
+     */
+
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: esItems
+      });
+    } 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,
+        entry,
+        latestStorageEntry,
+        publishedStorageEntry
+      });
+    }
+
+    return storageEntry;
+  };
+
+  const unpublish = async (model, params) => {
+    const {
+      entry,
+      storageEntry
+    } = 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);
+    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)()
+    })];
+    /**
+     * If we are unpublishing the latest revision, let's also update the latest revision entry's status in ES.
+     */
+
+    if (latestStorageEntry.id === entry.id) {
+      const {
+        index
+      } = _configurations.default.es({
+        model
+      });
+
+      const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
+        plugins,
+        model,
+        entry: (0, _lodash.default)(entry),
+        storageEntry: (0, _lodash.default)(storageEntry)
+      });
+      const esLatestData = await getESLatestEntryData(plugins, preparedEntryData);
+      esItems.push(esEntity.putBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        index,
+        data: esLatestData
+      }));
+    }
+    /**
+     * Finally, execute regular table batch.
+     */
+
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not store unpublished entry records in DynamoDB table.", ex.code || "UNPUBLISH_ERROR", {
+        entry,
+        storageEntry
+      });
+    }
+    /**
+     * And Elasticsearch table batch.
+     */
+
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: esItems
+      });
+    } 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;
+  };
+
+  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({
+      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
+    });
+
+    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
+      });
+    }
+
+    return storageEntry;
+  };
+
+  const getAllRevisionsByIds = async (model, params) => {
+    return await dataLoaders.getAllEntryRevisions({
+      model,
+      ids: params.ids
+    });
+  };
+
+  const getLatestRevisionByEntryId = async (model, params) => {
+    const result = await dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: [params.id]
+    });
+
+    if (result.length === 0) {
+      return null;
+    }
+
+    return result.shift();
+  };
+
+  const getPublishedRevisionByEntryId = async (model, params) => {
+    const result = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [params.id]
+    });
+
+    if (result.length === 0) {
+      return null;
+    }
+
+    return result.shift();
+  };
+
+  const getRevisionById = async (model, params) => {
+    const result = await dataLoaders.getRevisionById({
+      model,
+      ids: [params.id]
+    });
+
+    if (result.length === 0) {
+      return null;
+    }
+
+    return result.shift();
+  };
+
+  const getRevisions = async (model, params) => {
+    return await dataLoaders.getAllEntryRevisions({
+      model,
+      ids: [params.id]
+    });
+  };
+
+  const getByIds = async (model, params) => {
+    return dataLoaders.getRevisionById({
+      model,
+      ids: params.ids
+    });
+  };
+
+  const getLatestByIds = async (model, params) => {
+    return dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: params.ids
+    });
+  };
+
+  const getPublishedByIds = async (model, params) => {
+    return dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: params.ids
+    });
+  };
+
+  const getPreviousRevision = async (model, params) => {
+    const {
+      tenant,
+      locale
+    } = model;
+    const {
+      entryId,
+      version
+    } = params;
+    const queryParams = {
+      entity,
+      partitionKey: (0, _keys.createPartitionKey)({
+        tenant,
+        locale,
+        id: entryId
+      }),
+      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()
+        }, {
+          attr: "version",
+          lt: version
+        }],
+        reverse: true
+      }
+    };
+
+    try {
+      const result = await (0, _query.queryOne)(queryParams);
+      return (0, _cleanup.cleanupItem)(entity, result);
+    } 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), {}, {
+        error: ex,
+        partitionKey: queryParams.partitionKey,
+        options: queryParams.options,
+        model
+      }));
+    }
+  };
+
+  return {
+    create,
+    createRevisionFrom,
+    update,
+    delete: deleteEntry,
+    deleteRevision,
+    get,
+    publish,
+    unpublish,
+    requestReview,
+    requestChanges,
+    list,
+    getAllRevisionsByIds,
+    getLatestRevisionByEntryId,
+    getPublishedRevisionByEntryId,
+    getRevisionById,
+    getRevisions,
+    getByIds,
+    getLatestByIds,
+    getPublishedByIds,
+    getPreviousRevision
+  };
+};
+
+exports.createEntriesStorageOperations = createEntriesStorageOperations;