@webiny/api-headless-cms-ddb-es 0.0.0-ee-vpcs.549378cf03

package/operations/entry/index.js

@@ -0,0 +1,1251 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEntriesStorageOperations = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _types = require("@webiny/api-headless-cms/types");
+
+var _helpers = require("../../helpers");
+
+var _configurations = require("../../configurations");
+
+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 _apiElasticsearch = require("@webiny/api-elasticsearch");
+
+var _get = require("@webiny/db-dynamodb/utils/get");
+
+var _utils = require("@webiny/utils");
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _body = require("./elasticsearch/body");
+
+var _recordType = require("./recordType");
+
+const getEntryData = input => {
+  const output = (0, _objectSpread2.default)({}, input);
+  delete output["PK"];
+  delete output["SK"];
+  delete output["published"];
+  delete output["latest"];
+  return output;
+};
+
+const getESLatestEntryData = async (plugins, entry) => {
+  return (0, _apiElasticsearch.compress)(plugins, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, getEntryData(entry)), {}, {
+    latest: true,
+    TYPE: (0, _recordType.createLatestRecordType)(),
+    __type: (0, _recordType.createLatestRecordType)()
+  }));
+};
+
+const getESPublishedEntryData = async (plugins, entry) => {
+  return (0, _apiElasticsearch.compress)(plugins, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, getEntryData(entry)), {}, {
+    published: true,
+    TYPE: (0, _recordType.createPublishedRecordType)(),
+    __type: (0, _recordType.createPublishedRecordType)()
+  }));
+};
+
+const convertEntryKeysToStorage = params => {
+  const {
+    model,
+    entry
+  } = params;
+  const values = model.convertValueKeyToStorage({
+    fields: model.fields,
+    values: entry.values
+  });
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
+    values
+  });
+};
+
+const convertEntryKeysFromStorage = params => {
+  const {
+    model,
+    entry
+  } = params;
+  const values = model.convertValueKeyFromStorage({
+    fields: model.fields,
+    values: entry.values
+  });
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
+    values
+  });
+};
+
+const createEntriesStorageOperations = params => {
+  const {
+    entity,
+    esEntity,
+    elasticsearch,
+    plugins
+  } = params;
+  const dataLoaders = new _dataLoaders.DataLoadersHandler({
+    entity
+  });
+
+  const create = async (model, params) => {
+    const {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const isPublished = initialEntry.status === "published";
+    const locked = isPublished ? true : initialEntry.locked;
+    const entry = convertEntryKeysToStorage({
+      model,
+      entry: initialEntry
+    });
+    const storageEntry = convertEntryKeysToStorage({
+      model,
+      entry: initialStorageEntry
+    });
+    const esEntry = (0, _helpers.prepareEntryToIndex)({
+      plugins,
+      model,
+      entry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
+        locked
+      })),
+      storageEntry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked
+      }))
+    });
+
+    const {
+      index: esIndex
+    } = _configurations.configurations.es({
+      model
+    });
+
+    const esLatestData = await getESLatestEntryData(plugins, esEntry);
+    const esPublishedData = await getESPublishedEntryData(plugins, esEntry);
+    const revisionKeys = {
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    };
+    const latestKeys = {
+      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)()
+    };
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      locked
+    }, revisionKeys), {}, {
+      TYPE: (0, _recordType.createRecordType)()
+    })), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      locked
+    }, latestKeys), {}, {
+      TYPE: (0, _recordType.createLatestRecordType)()
+    }))];
+
+    if (isPublished) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked
+      }, publishedKeys), {}, {
+        TYPE: (0, _recordType.createPublishedRecordType)()
+      })));
+    }
+
+    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
+      });
+    }
+
+    const esItems = [esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestKeys), {}, {
+      index: esIndex,
+      data: esLatestData
+    }))];
+
+    if (isPublished) {
+      esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedKeys), {}, {
+        index: esIndex,
+        data: esPublishedData
+      })));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: esItems
+      });
+    } 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 initialStorageEntry;
+  };
+
+  const createRevisionFrom = async (model, params) => {
+    const {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const entry = convertEntryKeysToStorage({
+      model,
+      entry: initialEntry
+    });
+    const storageEntry = convertEntryKeysToStorage({
+      model,
+      entry: initialStorageEntry
+    });
+    const revisionKeys = {
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    };
+    const latestKeys = {
+      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, _cloneDeep.default)(entry),
+      storageEntry: (0, _cloneDeep.default)(storageEntry)
+    });
+    const esLatestData = await getESLatestEntryData(plugins, esEntry);
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      TYPE: (0, _recordType.createRecordType)()
+    }, revisionKeys)), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      TYPE: (0, _recordType.createLatestRecordType)()
+    }, latestKeys))];
+
+    const {
+      index
+    } = _configurations.configurations.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,
+        entry,
+        storageEntry
+      });
+    }
+    /**
+     * Update the "latest" entry item in the Elasticsearch
+     */
+
+
+    try {
+      await esEntity.put((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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,
+        entry
+      });
+    }
+    /**
+     * There are no modifications on the entry created so just return the data.
+     */
+
+
+    return initialStorageEntry;
+  };
+
+  const update = async (model, params) => {
+    const {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const entry = convertEntryKeysToStorage({
+      model,
+      entry: initialEntry
+    });
+    const storageEntry = convertEntryKeysToStorage({
+      model,
+      entry: initialStorageEntry
+    });
+    const isPublished = entry.status === "published";
+    const locked = isPublished ? true : entry.locked;
+    const revisionKeys = {
+      PK: (0, _keys.createPartitionKey)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    };
+    const latestKeys = {
+      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: [entry.id]
+    });
+    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [entry.id]
+    });
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      locked
+    }, revisionKeys), {}, {
+      TYPE: (0, _recordType.createRecordType)()
+    }))];
+
+    if (isPublished) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked
+      }, publishedKeys), {}, {
+        TYPE: (0, _recordType.createPublishedRecordType)()
+      })));
+    }
+
+    const esItems = [];
+
+    const {
+      index: esIndex
+    } = _configurations.configurations.es({
+      model
+    });
+    /**
+     * Variable for the elasticsearch entry so we do not convert it more than once
+     */
+
+
+    let esEntry = undefined;
+    /**
+     * If the latest entry is the one being updated, we need to create a new latest entry records.
+     */
+
+    let elasticsearchLatestData = null;
+
+    if ((latestStorageEntry === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
+      /**
+       * First we update the regular DynamoDB table
+       */
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), latestKeys), {}, {
+        TYPE: (0, _keys.createLatestSortKey)()
+      })));
+      /**
+       * And then update the Elasticsearch table to propagate changes to the Elasticsearch
+       */
+
+      esEntry = (0, _helpers.prepareEntryToIndex)({
+        plugins,
+        model,
+        entry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
+          locked
+        })),
+        storageEntry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+          locked
+        }))
+      });
+      elasticsearchLatestData = await getESLatestEntryData(plugins, esEntry);
+      esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestKeys), {}, {
+        index: esIndex,
+        data: elasticsearchLatestData
+      })));
+    }
+
+    let elasticsearchPublishedData = null;
+
+    if (isPublished && (publishedStorageEntry === null || publishedStorageEntry === void 0 ? void 0 : publishedStorageEntry.id) === entry.id) {
+      if (!elasticsearchLatestData) {
+        /**
+         * And then update the Elasticsearch table to propagate changes to the Elasticsearch
+         */
+        if (!esEntry) {
+          esEntry = (0, _helpers.prepareEntryToIndex)({
+            plugins,
+            model,
+            entry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
+              locked
+            })),
+            storageEntry: (0, _cloneDeep.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+              locked
+            }))
+          });
+        }
+
+        elasticsearchPublishedData = await getESPublishedEntryData(plugins, esEntry);
+      } else {
+        elasticsearchPublishedData = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, elasticsearchLatestData), {}, {
+          published: true,
+          TYPE: (0, _recordType.createPublishedRecordType)(),
+          __type: (0, _recordType.createPublishedRecordType)()
+        });
+        delete elasticsearchPublishedData.latest;
+      }
+
+      esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedKeys), {}, {
+        index: esIndex,
+        data: elasticsearchPublishedData
+      })));
+    }
+
+    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,
+        entry,
+        storageEntry
+      });
+    }
+
+    if (esItems.length === 0) {
+      return initialStorageEntry;
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: esItems
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update entry DynamoDB Elasticsearch records.", ex.code || "UPDATE_ES_ENTRY_ERROR", {
+        error: ex,
+        entry
+      });
+    }
+
+    return initialStorageEntry;
+  };
+
+  const deleteEntry = async (model, params) => {
+    const {
+      entry
+    } = params;
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    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 {
+      entry,
+      latestEntry,
+      latestStorageEntry
+    } = params;
+    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 items = [
+    /**
+     * Delete records of given entry revision.
+     */
+    entity.deleteBatch({
+      PK: partitionKey,
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    })];
+    const esItems = [];
+    /**
+     * If revision we are deleting is the published one as well, we need to delete those records as well.
+     */
+
+    if ((publishedStorageEntry === null || publishedStorageEntry === void 0 ? void 0 : publishedStorageEntry.id) === entry.id) {
+      items.push(entity.deleteBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }));
+      esItems.push(entity.deleteBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }));
+    }
+
+    if (latestEntry && latestStorageEntry) {
+      const esEntry = (0, _helpers.prepareEntryToIndex)({
+        plugins,
+        model,
+        entry: (0, _cloneDeep.default)(latestEntry),
+        storageEntry: (0, _cloneDeep.default)(latestStorageEntry)
+      });
+      const esLatestData = await getESLatestEntryData(plugins, esEntry);
+      /**
+       * In the end we need to set the new latest entry
+       */
+
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestStorageEntry), {}, {
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: (0, _recordType.createLatestRecordType)()
+      })));
+      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,
+        entry,
+        latestEntry,
+        latestStorageEntry
+      });
+    }
+
+    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,
+        entry,
+        latestEntry,
+        latestStorageEntry
+      });
+    }
+  };
+
+  const list = async (model, params) => {
+    var _response, _response$body;
+
+    const limit = (0, _apiElasticsearch.createLimit)(params.limit, 50);
+
+    const {
+      index
+    } = _configurations.configurations.es({
+      model
+    });
+
+    try {
+      const result = await elasticsearch.indices.exists({
+        index
+      });
+
+      if (!(result !== null && result !== void 0 && result.body)) {
+        return {
+          hasMoreItems: false,
+          totalCount: 0,
+          cursor: null,
+          items: []
+        };
+      }
+    } catch (ex) {
+      throw new _error.default("Could not determine if Elasticsearch index exists.", "ELASTICSEARCH_INDEX_CHECK_ERROR", {
+        error: ex,
+        index
+      });
+    }
+
+    const body = (0, _body.createElasticsearchBody)({
+      model,
+      params: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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,
+        index,
+        body,
+        model
+      });
+    }
+
+    const {
+      hits,
+      total
+    } = ((_response = response) === null || _response === void 0 ? void 0 : (_response$body = _response.body) === null || _response$body === void 0 ? void 0 : _response$body.hits) || {};
+    const items = (0, _helpers.extractEntriesFromIndex)({
+      plugins,
+      model,
+      entries: hits.map(item => item._source)
+    }).map(item => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry: item
+      });
+    });
+    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, _apiElasticsearch.encodeCursor)(hits[items.length - 1].sort) || null : null;
+    return {
+      hasMoreItems,
+      totalCount: total.value,
+      cursor,
+      items
+    };
+  };
+
+  const get = async (model, params) => {
+    const {
+      items
+    } = await list(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
+      limit: 1
+    }));
+    return items.shift() || null;
+  };
+
+  const publish = async (model, params) => {
+    const {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const entry = convertEntryKeysToStorage({
+      model,
+      entry: initialEntry
+    });
+    const storageEntry = convertEntryKeysToStorage({
+      model,
+      entry: initialStorageEntry
+    });
+    /**
+     * 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)({
+        id: entry.id,
+        locale: model.locale,
+        tenant: model.tenant
+      }),
+      SK: (0, _keys.createRevisionSortKey)(entry)
+    };
+    const latestKeys = {
+      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)()
+    };
+    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((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), revisionKeys), {}, {
+      TYPE: (0, _recordType.createRecordType)()
+    }))];
+    const esItems = [];
+
+    const {
+      index
+    } = _configurations.configurations.es({
+      model
+    });
+
+    if (publishedStorageEntry && publishedStorageEntry.id !== entry.id) {
+      /**
+       * 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((0, _objectSpread2.default)((0, _objectSpread2.default)({}, previouslyPublishedEntry), {}, {
+        status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
+        savedOn: entry.savedOn,
+        TYPE: (0, _recordType.createRecordType)(),
+        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((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), publishedKeys), {}, {
+      TYPE: (0, _recordType.createPublishedRecordType)()
+    })));
+    /**
+     * 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 === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), latestKeys)));
+    }
+    /**
+     * If we are publishing the latest revision, let's also update the latest revision's status in ES.
+     */
+
+
+    if (latestEsEntry && (latestStorageEntry === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
+      /**
+       * 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);
+      esItems.push(esEntity.putBatch({
+        index,
+        PK: (0, _keys.createPartitionKey)(latestEsEntryDataDecompressed),
+        SK: (0, _keys.createLatestSortKey)(),
+        data: await getESLatestEntryData(plugins, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestEsEntryDataDecompressed), {}, {
+          status: _types.CONTENT_ENTRY_STATUS.PUBLISHED,
+          locked: true,
+          savedOn: entry.savedOn,
+          publishedOn: entry.publishedOn
+        }))
+      }));
+    }
+
+    const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
+      plugins,
+      model,
+      entry: (0, _cloneDeep.default)(entry),
+      storageEntry: (0, _cloneDeep.default)(storageEntry)
+    });
+    /**
+     * Update the published revision entry in ES.
+     */
+
+    const esPublishedData = await getESPublishedEntryData(plugins, preparedEntryData);
+    esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedKeys), {}, {
+      index,
+      data: esPublishedData
+    })));
+    /**
+     * 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 initialStorageEntry;
+  };
+
+  const unpublish = async (model, params) => {
+    const {
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const entry = convertEntryKeysToStorage({
+      model,
+      entry: initialEntry
+    });
+    const storageEntry = convertEntryKeysToStorage({
+      model,
+      entry: initialStorageEntry
+    });
+    /**
+     * 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)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const items = [entity.deleteBatch({
+      PK: partitionKey,
+      SK: (0, _keys.createPublishedSortKey)()
+    }), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: (0, _keys.createRevisionSortKey)(entry),
+      TYPE: (0, _recordType.createRecordType)()
+    }))];
+    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 === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
+      const {
+        index
+      } = _configurations.configurations.es({
+        model
+      });
+
+      const preparedEntryData = (0, _helpers.prepareEntryToIndex)({
+        plugins,
+        model,
+        entry: (0, _cloneDeep.default)(entry),
+        storageEntry: (0, _cloneDeep.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 initialStorageEntry;
+  };
+
+  const getLatestRevisionByEntryId = async (model, params) => {
+    const [entry] = await dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: [params.id]
+    });
+
+    if (!entry) {
+      return null;
+    }
+
+    return convertEntryKeysFromStorage({
+      model,
+      entry
+    });
+  };
+
+  const getPublishedRevisionByEntryId = async (model, params) => {
+    const [entry] = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [params.id]
+    });
+
+    if (!entry) {
+      return null;
+    }
+
+    return convertEntryKeysFromStorage({
+      model,
+      entry
+    });
+  };
+
+  const getRevisionById = async (model, params) => {
+    const [entry] = await dataLoaders.getRevisionById({
+      model,
+      ids: [params.id]
+    });
+
+    if (!entry) {
+      return null;
+    }
+
+    return convertEntryKeysFromStorage({
+      model,
+      entry
+    });
+  };
+
+  const getRevisions = async (model, params) => {
+    const entries = await dataLoaders.getAllEntryRevisions({
+      model,
+      ids: [params.id]
+    });
+    return entries.map(entry => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry
+      });
+    });
+  };
+
+  const getByIds = async (model, params) => {
+    const entries = await dataLoaders.getRevisionById({
+      model,
+      ids: params.ids
+    });
+    return entries.map(entry => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry
+      });
+    });
+  };
+
+  const getLatestByIds = async (model, params) => {
+    const entries = await dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: params.ids
+    });
+    return entries.map(entry => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry
+      });
+    });
+  };
+
+  const getPublishedByIds = async (model, params) => {
+    const entries = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: params.ids
+    });
+    return entries.map(entry => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry
+      });
+    });
+  };
+
+  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: (0, _recordType.createRecordType)()
+        }, {
+          attr: "version",
+          lt: version
+        }],
+        reverse: true
+      }
+    };
+
+    try {
+      const result = await (0, _query.queryOne)(queryParams);
+      const entry = (0, _cleanup.cleanupItem)(entity, result);
+
+      if (!entry) {
+        return null;
+      }
+
+      return 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", (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
+        error: ex,
+        partitionKey: queryParams.partitionKey,
+        options: queryParams.options,
+        model
+      }));
+    }
+  };
+
+  return {
+    create,
+    createRevisionFrom,
+    update,
+    delete: deleteEntry,
+    deleteRevision,
+    get,
+    publish,
+    unpublish,
+    list,
+    getLatestRevisionByEntryId,
+    getPublishedRevisionByEntryId,
+    getRevisionById,
+    getRevisions,
+    getByIds,
+    getLatestByIds,
+    getPublishedByIds,
+    getPreviousRevision
+  };
+};
+
+exports.createEntriesStorageOperations = createEntriesStorageOperations;