@webiny/api-headless-cms-ddb-es 0.0.0-mt-3 → 0.0.0-unstable.2af142b57e

package/operations/entry/index.js

@@ -1,89 +1,74 @@
 "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 _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 = _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 _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 _limit = require("@webiny/api-elasticsearch/limit");
-
-var _cursors = require("@webiny/api-elasticsearch/cursors");
-
+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");
-
-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`;
+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;
 };
-
-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)), {}, {
+  return (0, _apiElasticsearch.compress)(plugins, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, getEntryData(entry)), {}, {
     latest: true,
-    TYPE: createLatestType(),
-    __type: createLatestType()
+    TYPE: (0, _recordType.createLatestRecordType)(),
+    __type: (0, _recordType.createLatestRecordType)()
   }));
 };
-
 const getESPublishedEntryData = async (plugins, entry) => {
-  return (0, _compression.compress)(plugins, _objectSpread(_objectSpread({}, getEntryData(entry)), {}, {
+  return (0, _apiElasticsearch.compress)(plugins, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, getEntryData(entry)), {}, {
     published: true,
-    TYPE: createPublishedType(),
-    __type: createPublishedType()
+    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,
@@ -94,40 +79,78 @@ const createEntriesStorageOperations = params => {
   const dataLoaders = new _dataLoaders.DataLoadersHandler({
     entity
   });
-
   const create = async (model, params) => {
     const {
-      entry,
-      storageEntry
+      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, _lodash.default)(entry),
-      storageEntry: (0, _lodash.default)(storageEntry)
+      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.default.es({
+    } = _configurations.configurations.es({
       model
     });
-
     const esLatestData = await getESLatestEntryData(plugins, esEntry);
+    const esPublishedData = await getESPublishedEntryData(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()
+    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,
@@ -143,12 +166,21 @@ const createEntriesStorageOperations = params => {
         storageEntry
       });
     }
-
-    try {
-      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
+    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: esLatestData
-      }));
+        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,
@@ -156,43 +188,54 @@ const createEntriesStorageOperations = params => {
         esEntry
       });
     }
-
-    return storageEntry;
+    return initialStorageEntry;
   };
-
   const createRevisionFrom = async (model, params) => {
     const {
-      originalEntry,
-      entry,
-      storageEntry
+      entry: initialEntry,
+      storageEntry: initialStorageEntry
     } = params;
+    const entry = convertEntryKeysToStorage({
+      model,
+      entry: initialEntry
+    });
+    const storageEntry = convertEntryKeysToStorage({
+      model,
+      entry: initialStorageEntry
+    });
     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)
+      entry: (0, _cloneDeep.default)(entry),
+      storageEntry: (0, _cloneDeep.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()
+    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.default.es({
+    } = _configurations.configurations.es({
       model
     });
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -204,7 +247,6 @@ const createEntriesStorageOperations = params => {
     } 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
       });
@@ -212,79 +254,157 @@ const createEntriesStorageOperations = params => {
     /**
      * Update the "latest" entry item in the Elasticsearch
      */
-
-
     try {
-      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
+      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,
-        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 {
-      originalEntry,
-      entry,
-      storageEntry
+      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)(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 items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), revisionKeys), {}, {
-      TYPE: createType()
+    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.id === originalEntry.id) {
+    if ((latestStorageEntry === null || latestStorageEntry === void 0 ? void 0 : latestStorageEntry.id) === entry.id) {
       /**
        * First we update the regular DynamoDB table
        */
-      items.push(entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), latestKeys), {}, {
+      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
        */
-
-      const esEntry = (0, _helpers.prepareEntryToIndex)({
+      esEntry = (0, _helpers.prepareEntryToIndex)({
         plugins,
         model,
-        entry: (0, _lodash.default)(entry),
-        storageEntry: (0, _lodash.default)(storageEntry)
+        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,
@@ -296,43 +416,35 @@ const createEntriesStorageOperations = params => {
     } 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;
+    if (esItems.length === 0) {
+      return initialStorageEntry;
     }
-
-    const {
-      index: esIndex
-    } = _configurations.default.es({
-      model
-    });
-
     try {
-      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
-        index: esIndex,
-        data: elasticsearchLatestData
-      }));
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: esItems
+      });
     } 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 partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
     const items = await (0, _query.queryAll)({
       entity,
       partitionKey,
@@ -359,7 +471,6 @@ const createEntriesStorageOperations = params => {
         SK: item.SK
       });
     });
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -374,7 +485,6 @@ const createEntriesStorageOperations = params => {
         entry
       });
     }
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: esEntity.table,
@@ -387,47 +497,46 @@ const createEntriesStorageOperations = params => {
       });
     }
   };
-
   const deleteRevision = async (model, params) => {
     const {
-      entryToDelete,
-      entryToSetAsLatest,
-      storageEntryToSetAsLatest
+      entry,
+      latestEntry,
+      latestStorageEntry
     } = params;
-    const partitionKey = (0, _keys.createPartitionKey)(entryToDelete);
-
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
     const {
       index
-    } = _configurations.default.es({
+    } = _configurations.configurations.es({
       model
     });
     /**
      * We need published entry to delete it if necessary.
      */
-
-
     const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
       model,
-      ids: [entryToDelete.id]
+      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)(entryToDelete)
+      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 && entryToDelete.id === publishedStorageEntry.id) {
+    if ((publishedStorageEntry === null || publishedStorageEntry === void 0 ? void 0 : publishedStorageEntry.id) === entry.id) {
       items.push(entity.deleteBatch({
         PK: partitionKey,
         SK: (0, _keys.createPublishedSortKey)()
@@ -437,23 +546,21 @@ const createEntriesStorageOperations = params => {
         SK: (0, _keys.createPublishedSortKey)()
       }));
     }
-
-    if (entryToSetAsLatest) {
+    if (latestEntry && latestStorageEntry) {
       const esEntry = (0, _helpers.prepareEntryToIndex)({
         plugins,
         model,
-        entry: (0, _lodash.default)(entryToSetAsLatest),
-        storageEntry: (0, _lodash.default)(storageEntryToSetAsLatest)
+        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(_objectSpread(_objectSpread({}, storageEntryToSetAsLatest), {}, {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestStorageEntry), {}, {
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
-        TYPE: createLatestType()
+        TYPE: (0, _recordType.createLatestRecordType)()
       })));
       esItems.push(esEntity.putBatch({
         PK: partitionKey,
@@ -462,7 +569,6 @@ const createEntriesStorageOperations = params => {
         data: esLatestData
       }));
     }
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -474,16 +580,14 @@ const createEntriesStorageOperations = params => {
     } 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
+        entry,
+        latestEntry,
+        latestStorageEntry
       });
     }
-
     if (esItems.length === 0) {
       return;
     }
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: esEntity.table,
@@ -492,31 +596,47 @@ const createEntriesStorageOperations = params => {
     } 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,
+        latestStorageEntry
       });
     }
   };
-
   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;
-
+    var _response, _response$body;
+    const limit = (0, _apiElasticsearch.createLimit)(params.limit, 50);
     const {
       index
-    } = _configurations.default.es({
+    } = _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,
@@ -526,21 +646,25 @@ const createEntriesStorageOperations = params => {
       throw new _error.default(ex.message, ex.code || "ELASTICSEARCH_ERROR", {
         error: ex,
         index,
-        body
+        body,
+        model
       });
     }
-
     const {
       hits,
       total
-    } = response.body.hits;
+    } = ((_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.
@@ -551,9 +675,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,48 +683,60 @@ const createEntriesStorageOperations = params => {
       items
     };
   };
-
   const get = async (model, params) => {
     const {
       items
-    } = await list(model, _objectSpread(_objectSpread({}, params), {}, {
+    } = await list(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
       limit: 1
     }));
-
-    if (items.length === 0) {
-      return null;
-    }
-
-    return items.shift();
+    return items.shift() || null;
   };
-
   const publish = async (model, params) => {
     const {
-      entry,
-      storageEntry
+      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)(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)({
         entity: esEntity,
@@ -615,19 +749,16 @@ const createEntriesStorageOperations = params => {
         publishedKeys: publishedKeys
       });
     }
-
-    const items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), revisionKeys), {}, {
-      TYPE: createType()
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), revisionKeys), {}, {
+      TYPE: (0, _recordType.createRecordType)()
     }))];
     const esItems = [];
-
     const {
       index
-    } = _configurations.default.es({
+    } = _configurations.configurations.es({
       model
     });
-
-    if (publishedStorageEntry) {
+    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.
@@ -643,10 +774,10 @@ const createEntriesStorageOperations = params => {
       /**
        * Update currently published entry (unpublish it)
        */
-      entity.putBatch(_objectSpread(_objectSpread({}, previouslyPublishedEntry), {}, {
+      entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, previouslyPublishedEntry), {}, {
         status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
         savedOn: entry.savedOn,
-        TYPE: createType(),
+        TYPE: (0, _recordType.createRecordType)(),
         PK: (0, _keys.createPartitionKey)(publishedStorageEntry),
         SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry)
       })));
@@ -654,60 +785,60 @@ const createEntriesStorageOperations = params => {
     /**
      * Update the helper item in DB with the new published entry
      */
-
-
-    items.push(entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, storageEntry), publishedKeys), {}, {
-      TYPE: createPublishedType()
+    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 neds to be updated as well in the Elasticsearch.
+     * 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 (latestStorageEntry && latestStorageEntry.id === entry.id) {
+    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, _compression.decompress)(plugins, latestEsEntry.data);
+      const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
       esItems.push(esEntity.putBatch({
         index,
         PK: (0, _keys.createPartitionKey)(latestEsEntryDataDecompressed),
         SK: (0, _keys.createLatestSortKey)(),
-        data: _objectSpread(_objectSpread({}, latestEsEntryDataDecompressed), {}, {
+        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, _lodash.default)(entry),
-      storageEntry: (0, _lodash.default)(storageEntry)
+      entry: (0, _cloneDeep.default)(entry),
+      storageEntry: (0, _cloneDeep.default)(storageEntry)
     });
     /**
      * Update the published revision entry in ES.
      */
-
-    const esLatestData = await getESPublishedEntryData(plugins, preparedEntryData);
-    esItems.push(esEntity.putBatch(_objectSpread(_objectSpread({}, publishedKeys), {}, {
+    const esPublishedData = await getESPublishedEntryData(plugins, preparedEntryData);
+    esItems.push(esEntity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedKeys), {}, {
       index,
-      data: esLatestData
+      data: esPublishedData
     })));
+
     /**
      * Finally, execute regular table batch.
      */
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -727,8 +858,6 @@ const createEntriesStorageOperations = params => {
     /**
      * And Elasticsearch table batch.
      */
-
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: esEntity.table,
@@ -742,31 +871,41 @@ const createEntriesStorageOperations = params => {
         publishedStorageEntry
       });
     }
-
-    return storageEntry;
+    return initialStorageEntry;
   };
-
   const unpublish = async (model, params) => {
     const {
-      entry,
-      storageEntry
+      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)(entry);
+    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(_objectSpread(_objectSpread({}, storageEntry), {}, {
+    }), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
       PK: partitionKey,
       SK: (0, _keys.createRevisionSortKey)(entry),
-      TYPE: createType()
+      TYPE: (0, _recordType.createRecordType)()
     }))];
     const esItems = [esEntity.deleteBatch({
       PK: partitionKey,
@@ -775,19 +914,17 @@ const createEntriesStorageOperations = params => {
     /**
      * If we are unpublishing the latest revision, let's also update the latest revision entry's status in ES.
      */
-
-    if (latestStorageEntry.id === entry.id) {
+    if ((latestStorageEntry === null || latestStorageEntry === void 0 ? void 0 : 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)
+        entry: (0, _cloneDeep.default)(entry),
+        storageEntry: (0, _cloneDeep.default)(storageEntry)
       });
       const esLatestData = await getESLatestEntryData(plugins, preparedEntryData);
       esItems.push(esEntity.putBatch({
@@ -797,11 +934,10 @@ const createEntriesStorageOperations = params => {
         data: esLatestData
       }));
     }
+
     /**
      * Finally, execute regular table batch.
      */
-
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: entity.table,
@@ -819,8 +955,6 @@ const createEntriesStorageOperations = params => {
     /**
      * And Elasticsearch table batch.
      */
-
-
     try {
       await (0, _batchWrite.batchWriteAll)({
         table: esEntity.table,
@@ -832,253 +966,95 @@ const createEntriesStorageOperations = params => {
         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;
+    return initialStorageEntry;
   };
-
-  const getAllRevisionsByIds = async (model, params) => {
-    return await dataLoaders.getAllEntryRevisions({
-      model,
-      ids: params.ids
-    });
-  };
-
   const getLatestRevisionByEntryId = async (model, params) => {
-    const result = await dataLoaders.getLatestRevisionByEntryId({
+    const [entry] = await dataLoaders.getLatestRevisionByEntryId({
       model,
       ids: [params.id]
     });
-
-    if (result.length === 0) {
+    if (!entry) {
       return null;
     }
-
-    return result.shift();
+    return convertEntryKeysFromStorage({
+      model,
+      entry
+    });
   };
-
   const getPublishedRevisionByEntryId = async (model, params) => {
-    const result = await dataLoaders.getPublishedRevisionByEntryId({
+    const [entry] = await dataLoaders.getPublishedRevisionByEntryId({
       model,
       ids: [params.id]
     });
-
-    if (result.length === 0) {
+    if (!entry) {
       return null;
     }
-
-    return result.shift();
+    return convertEntryKeysFromStorage({
+      model,
+      entry
+    });
   };
-
   const getRevisionById = async (model, params) => {
-    const result = await dataLoaders.getRevisionById({
+    const [entry] = await dataLoaders.getRevisionById({
       model,
       ids: [params.id]
     });
-
-    if (result.length === 0) {
+    if (!entry) {
       return null;
     }
-
-    return result.shift();
+    return convertEntryKeysFromStorage({
+      model,
+      entry
+    });
   };
-
   const getRevisions = async (model, params) => {
-    return await dataLoaders.getAllEntryRevisions({
+    const entries = await dataLoaders.getAllEntryRevisions({
       model,
       ids: [params.id]
     });
+    return entries.map(entry => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry
+      });
+    });
   };
-
   const getByIds = async (model, params) => {
-    return dataLoaders.getRevisionById({
+    const entries = await dataLoaders.getRevisionById({
       model,
       ids: params.ids
     });
+    return entries.map(entry => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry
+      });
+    });
   };
-
   const getLatestByIds = async (model, params) => {
-    return dataLoaders.getLatestRevisionByEntryId({
+    const entries = await dataLoaders.getLatestRevisionByEntryId({
       model,
       ids: params.ids
     });
+    return entries.map(entry => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry
+      });
+    });
   };
-
   const getPublishedByIds = async (model, params) => {
-    return dataLoaders.getPublishedRevisionByEntryId({
+    const entries = await dataLoaders.getPublishedRevisionByEntryId({
       model,
       ids: params.ids
     });
+    return entries.map(entry => {
+      return convertEntryKeysFromStorage({
+        model,
+        entry
+      });
+    });
   };
-
   const getPreviousRevision = async (model, params) => {
     const {
       tenant,
@@ -1097,13 +1073,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,12 +1086,18 @@ const createEntriesStorageOperations = params => {
         reverse: true
       }
     };
-
     try {
       const result = await (0, _query.queryOne)(queryParams);
-      return (0, _cleanup.cleanupItem)(entity, result);
+      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", _objectSpread(_objectSpread({}, params), {}, {
+      throw new _error.default(ex.message || "Could not get previous version of given entry.", ex.code || "GET_PREVIOUS_VERSION_ERROR", (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
         error: ex,
         partitionKey: queryParams.partitionKey,
         options: queryParams.options,
@@ -1124,7 +1105,6 @@ const createEntriesStorageOperations = params => {
       }));
     }
   };
-
   return {
     create,
     createRevisionFrom,
@@ -1134,10 +1114,7 @@ const createEntriesStorageOperations = params => {
     get,
     publish,
     unpublish,
-    requestReview,
-    requestChanges,
     list,
-    getAllRevisionsByIds,
     getLatestRevisionByEntryId,
     getPublishedRevisionByEntryId,
     getRevisionById,
@@ -1148,5 +1125,4 @@ const createEntriesStorageOperations = params => {
     getPreviousRevision
   };
 };
-
 exports.createEntriesStorageOperations = createEntriesStorageOperations;