@webiny/api-headless-cms-ddb-es 6.0.0-alpha.5 → 6.0.0-rc.0

package/operations/entry/index.js

@@ -1,27 +1,16 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createEntriesStorageOperations = void 0;
-var _error = _interopRequireDefault(require("@webiny/error"));
-var _types = require("@webiny/api-headless-cms/types");
-var _helpers = require("../../helpers");
-var _configurations = require("../../configurations");
-var _dbDynamodb = require("@webiny/db-dynamodb");
-var _dataLoaders = require("./dataLoaders");
-var _keys = require("./keys");
-var _apiElasticsearch = require("@webiny/api-elasticsearch");
-var _utils = require("@webiny/utils");
-var _body = require("./elasticsearch/body");
-var _logIgnoredEsResponseError = require("./elasticsearch/logIgnoredEsResponseError");
-var _shouldIgnoreEsResponseError = require("./elasticsearch/shouldIgnoreEsResponseError");
-var _recordType = require("./recordType");
-var _apiHeadlessCms = require("@webiny/api-headless-cms");
-var _transformations = require("./transformations");
-var _convertEntryKeys = require("./transformations/convertEntryKeys");
-var _constants = require("@webiny/api-headless-cms/constants");
+import WebinyError from "@webiny/error";
+import { CONTENT_ENTRY_STATUS } from "@webiny/api-headless-cms/types/index.js";
+import { extractEntriesFromIndex } from "../../helpers/index.js";
+import { configurations } from "../../configurations.js";
+import { DataLoadersHandler } from "./dataLoaders.js";
+import { createEntryLatestKeys, createEntryPublishedKeys, createEntryRevisionKeys, createLatestSortKey, createPartitionKey, createPublishedSortKey, createRevisionSortKey } from "./keys.js";
+import { compress, createLimit, decodeCursor, decompress, encodeCursor } from "@webiny/api-elasticsearch";
+import { createElasticsearchBody } from "./elasticsearch/body.js";
+import { shouldIgnoreEsResponseError } from "./elasticsearch/shouldIgnoreEsResponseError.js";
+import { StorageOperationsCmsModelPlugin } from "@webiny/api-headless-cms";
+import { createTransformer } from "./transformations/index.js";
+import { convertEntryKeysFromStorage } from "./transformations/convertEntryKeys.js";
+import { isDeletedEntryMetaField, isEntryLevelEntryMetaField, isRestoredEntryMetaField, pickEntryMetaFields } from "@webiny/api-headless-cms/constants.js";
 const convertToStorageEntry = params => {
   const {
     model,
@@ -36,7 +25,7 @@ const convertToStorageEntry = params => {
     values
   };
 };
-const createEntriesStorageOperations = params => {
+export const createEntriesStorageOperations = params => {
   const {
     entity,
     esEntity,
@@ -48,14 +37,14 @@ const createEntriesStorageOperations = params => {
     if (storageOperationsCmsModelPlugin) {
       return storageOperationsCmsModelPlugin;
     }
-    storageOperationsCmsModelPlugin = plugins.oneByType(_apiHeadlessCms.StorageOperationsCmsModelPlugin.type);
+    storageOperationsCmsModelPlugin = plugins.oneByType(StorageOperationsCmsModelPlugin.type);
     return storageOperationsCmsModelPlugin;
   };
   const getStorageOperationsModel = model => {
     const plugin = getStorageOperationsCmsModelPlugin();
     return plugin.getModel(model);
   };
-  const dataLoaders = new _dataLoaders.DataLoadersHandler({
+  const dataLoaders = new DataLoadersHandler({
     entity
   });
   const create = async (initialModel, params) => {
@@ -68,7 +57,7 @@ const createEntriesStorageOperations = params => {
     const locked = isPublished ? true : initialEntry.locked;
     initialEntry.locked = locked;
     initialStorageEntry.locked = locked;
-    const transformer = (0, _transformations.createTransformer)({
+    const transformer = createTransformer({
       plugins,
       model,
       entry: initialEntry,
@@ -81,53 +70,34 @@ const createEntriesStorageOperations = params => {
     const esEntry = transformer.transformToIndex();
     const {
       index: esIndex
-    } = _configurations.configurations.es({
+    } = configurations.es({
       model
     });
-    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 entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity,
+    const revisionKeys = createEntryRevisionKeys(entry);
+    const latestKeys = createEntryLatestKeys(entry);
+    const publishedKeys = createEntryPublishedKeys(entry);
+    const entityBatch = entity.createEntityWriter({
       put: [{
-        ...storageEntry,
-        locked,
         ...revisionKeys,
-        TYPE: (0, _recordType.createRecordType)()
+        data: {
+          ...storageEntry,
+          locked
+        }
       }, {
-        ...storageEntry,
-        locked,
         ...latestKeys,
-        TYPE: (0, _recordType.createLatestRecordType)()
+        data: {
+          ...storageEntry,
+          locked
+        }
       }]
     });
     if (isPublished) {
       entityBatch.put({
-        ...storageEntry,
-        locked,
         ...publishedKeys,
-        TYPE: (0, _recordType.createPublishedRecordType)()
+        data: {
+          ...storageEntry,
+          locked
+        }
       });
     }
     try {
@@ -136,15 +106,14 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not insert entry data into the DynamoDB table.", ex.code || "CREATE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not insert entry data into the DynamoDB table.", ex.code || "CREATE_ENTRY_ERROR", {
         error: ex,
         entry,
         storageEntry
       });
     }
     const esLatestData = await transformer.getElasticsearchLatestEntryData();
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity,
+    const elasticsearchEntityBatch = esEntity.createEntityWriter({
       put: [{
         ...latestKeys,
         index: esIndex,
@@ -162,7 +131,7 @@ const createEntriesStorageOperations = params => {
     try {
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not insert entry data into the Elasticsearch DynamoDB table.", ex.code || "CREATE_ES_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not insert entry data into the Elasticsearch DynamoDB table.", ex.code || "CREATE_ES_ENTRY_ERROR", {
         error: ex,
         entry,
         esEntry
@@ -176,7 +145,7 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const transformer = (0, _transformations.createTransformer)({
+    const transformer = createTransformer({
       plugins,
       model,
       entry: initialEntry,
@@ -186,51 +155,26 @@ const createEntriesStorageOperations = params => {
       entry,
       storageEntry
     } = transformer.transformEntryKeys();
-    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 revisionKeys = createEntryRevisionKeys(entry);
+    const latestKeys = createEntryLatestKeys(entry);
+    const publishedKeys = createEntryPublishedKeys(entry);
 
     // We'll need this flag below.
     const isPublished = entry.status === "published";
     const esLatestData = await transformer.getElasticsearchLatestEntryData();
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity,
+    const entityBatch = entity.createEntityWriter({
       put: [{
-        ...storageEntry,
-        TYPE: (0, _recordType.createRecordType)(),
-        ...revisionKeys
+        ...revisionKeys,
+        data: storageEntry
       }, {
-        ...storageEntry,
-        TYPE: (0, _recordType.createLatestRecordType)(),
-        ...latestKeys
+        ...latestKeys,
+        data: storageEntry
       }]
     });
     if (isPublished) {
       entityBatch.put({
-        ...storageEntry,
-        TYPE: (0, _recordType.createPublishedRecordType)(),
-        ...publishedKeys
+        ...publishedKeys,
+        data: storageEntry
       });
 
       // Unpublish previously published revision (if any).
@@ -239,16 +183,13 @@ const createEntriesStorageOperations = params => {
         ids: [entry.id]
       });
       if (publishedRevisionStorageEntry) {
+        const publishedRevisionKey = createEntryRevisionKeys(publishedRevisionStorageEntry);
         entityBatch.put({
-          ...publishedRevisionStorageEntry,
-          PK: (0, _keys.createPartitionKey)({
-            id: publishedRevisionStorageEntry.id,
-            locale: model.locale,
-            tenant: model.tenant
-          }),
-          SK: (0, _keys.createRevisionSortKey)(publishedRevisionStorageEntry),
-          TYPE: (0, _recordType.createRecordType)(),
-          status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED
+          ...publishedRevisionKey,
+          data: {
+            ...publishedRevisionStorageEntry,
+            status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+          }
         });
       }
     }
@@ -258,7 +199,7 @@ const createEntriesStorageOperations = params => {
         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", {
+      throw new WebinyError(ex.message || "Could not create revision from given entry in the DynamoDB table.", ex.code || "CREATE_REVISION_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -266,11 +207,10 @@ const createEntriesStorageOperations = params => {
     }
     const {
       index: esIndex
-    } = _configurations.configurations.es({
+    } = configurations.es({
       model
     });
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity,
+    const elasticsearchEntityBatch = esEntity.createEntityWriter({
       put: [{
         ...latestKeys,
         index: esIndex,
@@ -288,7 +228,7 @@ const createEntriesStorageOperations = params => {
     try {
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not update latest entry in the DynamoDB Elasticsearch table.", ex.code || "CREATE_REVISION_ERROR", {
+      throw new WebinyError(ex.message || "Could not update latest entry in the DynamoDB Elasticsearch table.", ex.code || "CREATE_REVISION_ERROR", {
         error: ex,
         entry
       });
@@ -304,7 +244,7 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const transformer = (0, _transformations.createTransformer)({
+    const transformer = createTransformer({
       plugins,
       model,
       entry: initialEntry,
@@ -316,30 +256,9 @@ const createEntriesStorageOperations = params => {
     } = transformer.transformEntryKeys();
     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)()
-    };
+    const revisionKeys = createEntryRevisionKeys(entry);
+    const latestKeys = createEntryLatestKeys(entry);
+    const publishedKeys = createEntryPublishedKeys(entry);
 
     /**
      * We need the latest entry to check if it needs to be updated.
@@ -352,29 +271,28 @@ const createEntriesStorageOperations = params => {
       model,
       ids: [entry.id]
     });
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity,
+    const entityBatch = entity.createEntityWriter({
       put: [{
-        ...storageEntry,
-        locked,
         ...revisionKeys,
-        TYPE: (0, _recordType.createRecordType)()
+        data: {
+          ...storageEntry,
+          locked
+        }
       }]
     });
     if (isPublished) {
       entityBatch.put({
-        ...storageEntry,
-        locked,
         ...publishedKeys,
-        TYPE: (0, _recordType.createPublishedRecordType)()
+        data: {
+          ...storageEntry,
+          locked
+        }
       });
     }
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity
-    });
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
     const {
       index: esIndex
-    } = _configurations.configurations.es({
+    } = configurations.es({
       model
     });
 
@@ -388,9 +306,8 @@ const createEntriesStorageOperations = params => {
          * First we update the regular DynamoDB table.
          */
         entityBatch.put({
-          ...storageEntry,
           ...latestKeys,
-          TYPE: (0, _recordType.createLatestRecordType)()
+          data: storageEntry
         });
 
         /**
@@ -407,11 +324,13 @@ const createEntriesStorageOperations = params => {
          * If not updating latest revision, we still want to update the latest revision's
          * entry-level meta fields to match the current revision's entry-level meta fields.
          */
-        const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
+        const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
         const updatedLatestStorageEntry = {
-          ...latestStorageEntry,
           ...latestKeys,
-          ...updatedEntryLevelMetaFields
+          data: {
+            ...latestStorageEntry,
+            ...updatedEntryLevelMetaFields
+          }
         };
 
         /**
@@ -421,29 +340,23 @@ const createEntriesStorageOperations = params => {
          */
         entityBatch.put({
           ...updatedLatestStorageEntry,
-          PK: (0, _keys.createPartitionKey)({
+          PK: createPartitionKey({
             id: latestStorageEntry.id,
-            locale: model.locale,
             tenant: model.tenant
           }),
-          SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
-          TYPE: (0, _recordType.createRecordType)()
+          SK: createRevisionSortKey(latestStorageEntry)
         });
         entityBatch.put({
-          ...updatedLatestStorageEntry,
-          TYPE: (0, _recordType.createLatestRecordType)()
+          ...updatedLatestStorageEntry
         });
 
         /**
          * Update the Elasticsearch table to propagate changes to the Elasticsearch.
          */
-        const latestEsEntry = await (0, _dbDynamodb.getClean)({
-          entity: esEntity,
-          keys: latestKeys
-        });
+        const latestEsEntry = await esEntity.getClean(latestKeys);
         if (latestEsEntry) {
-          const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
-          const updatedLatestEntry = await (0, _apiElasticsearch.compress)(plugins, {
+          const latestEsEntryDataDecompressed = await decompress(plugins, latestEsEntry.data);
+          const updatedLatestEntry = await compress(plugins, {
             ...latestEsEntryDataDecompressed,
             ...updatedEntryLevelMetaFields
           });
@@ -469,7 +382,7 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not update entry DynamoDB records.", ex.code || "UPDATE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not update entry DynamoDB records.", ex.code || "UPDATE_ENTRY_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -478,7 +391,7 @@ const createEntriesStorageOperations = params => {
     try {
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not update entry DynamoDB Elasticsearch records.", ex.code || "UPDATE_ES_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not update entry DynamoDB Elasticsearch records.", ex.code || "UPDATE_ES_ENTRY_ERROR", {
         error: ex,
         entry
       });
@@ -487,38 +400,37 @@ const createEntriesStorageOperations = params => {
   };
   const move = async (initialModel, id, folderId) => {
     const model = getStorageOperationsModel(initialModel);
-    const partitionKey = (0, _keys.createPartitionKey)({
+    const partitionKey = createPartitionKey({
       id,
-      locale: model.locale,
       tenant: model.tenant
     });
     /**
      * First we need to fetch all the records in the regular DynamoDB table.
      */
     const queryAllParams = {
-      entity,
       partitionKey,
       options: {
         gte: " "
       }
     };
-    const latestSortKey = (0, _keys.createLatestSortKey)();
-    const publishedSortKey = (0, _keys.createPublishedSortKey)();
-    const records = await (0, _dbDynamodb.queryAll)(queryAllParams);
+    const latestSortKey = createLatestSortKey();
+    const publishedSortKey = createPublishedSortKey();
+    const records = await entity.queryAll(queryAllParams);
     /**
      * Then update the folderId in each record and prepare it to be stored.
      */
     let latestRecord = undefined;
     let publishedRecord = undefined;
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity
-    });
+    const entityBatch = entity.createEntityWriter();
     for (const record of records) {
       entityBatch.put({
         ...record,
-        location: {
-          ...record?.location,
-          folderId
+        data: {
+          ...record.data,
+          location: {
+            ...record.data.location,
+            folderId
+          }
         }
       });
 
@@ -526,9 +438,9 @@ const createEntriesStorageOperations = params => {
        * We need to get the published and latest records, so we can update the Elasticsearch.
        */
       if (record.SK === publishedSortKey) {
-        publishedRecord = record;
+        publishedRecord = record.data;
       } else if (record.SK === latestSortKey) {
-        latestRecord = record;
+        latestRecord = record.data;
       }
     }
     try {
@@ -537,62 +449,58 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not move all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not move all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_ERROR", {
         error: ex,
         id
       });
     }
-    const esGetItems = [];
+    const esEntityReader = esEntity.createEntityReader();
     if (publishedRecord) {
-      esGetItems.push(esEntity.getBatch({
+      esEntityReader.get({
         PK: partitionKey,
         SK: publishedSortKey
-      }));
+      });
     }
     if (latestRecord) {
-      esGetItems.push(esEntity.getBatch({
+      esEntityReader.get({
         PK: partitionKey,
         SK: latestSortKey
-      }));
+      });
     }
-    if (esGetItems.length === 0) {
+    if (esEntityReader.total === 0) {
       return;
     }
-    const esRecords = await (0, _dbDynamodb.batchReadAll)({
-      table: esEntity.table,
-      items: esGetItems
-    });
+    const esRecords = await esEntityReader.execute();
     const esItems = (await Promise.all(esRecords.map(async record => {
       if (!record) {
         return null;
       }
       return {
         ...record,
-        data: await (0, _apiElasticsearch.decompress)(plugins, record.data)
+        data: await decompress(plugins, record.data)
       };
-    }))).filter(Boolean);
+    }))).filter(item => !!item);
     if (esItems.length === 0) {
       return;
     }
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity,
-      put: await Promise.all(esItems.map(async item => {
-        return {
-          ...item,
-          data: await (0, _apiElasticsearch.compress)(plugins, {
-            ...item.data,
-            location: {
-              ...item.data?.location,
-              folderId
-            }
-          })
-        };
-      }))
-    });
     try {
+      const elasticsearchEntityBatch = esEntity.createEntityWriter({
+        put: await Promise.all(esItems.map(async item => {
+          return {
+            ...item,
+            data: await compress(plugins, {
+              ...item.data,
+              location: {
+                ...item.data?.location,
+                folderId
+              }
+            })
+          };
+        }))
+      });
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not move entry DynamoDB Elasticsearch records.", ex.code || "MOVE_ES_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not move entry DynamoDB Elasticsearch records.", ex.code || "MOVE_ES_ENTRY_ERROR", {
         error: ex,
         partitionKey
       });
@@ -604,7 +512,7 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const transformer = (0, _transformations.createTransformer)({
+    const transformer = createTransformer({
       plugins,
       model,
       entry: initialEntry,
@@ -614,9 +522,8 @@ const createEntriesStorageOperations = params => {
       entry,
       storageEntry
     } = transformer.transformEntryKeys();
-    const partitionKey = (0, _keys.createPartitionKey)({
+    const partitionKey = createPartitionKey({
       id: entry.id,
-      locale: model.locale,
       tenant: model.tenant
     });
 
@@ -624,45 +531,45 @@ const createEntriesStorageOperations = params => {
      * First we need to fetch all the records in the regular DynamoDB table.
      */
     const queryAllParams = {
-      entity,
       partitionKey,
       options: {
         gte: " "
       }
     };
-    const latestSortKey = (0, _keys.createLatestSortKey)();
-    const publishedSortKey = (0, _keys.createPublishedSortKey)();
-    const records = await (0, _dbDynamodb.queryAll)(queryAllParams);
+    const latestSortKey = createLatestSortKey();
+    const publishedSortKey = createPublishedSortKey();
+    const records = await entity.queryAll(queryAllParams);
 
     /**
      * Let's pick the `deleted` meta fields from the entry.
      */
-    const updatedEntryMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isDeletedEntryMetaField);
+    const updatedEntryMetaFields = pickEntryMetaFields(entry, isDeletedEntryMetaField);
 
     /**
      * Then update all the records with data received.
      */
     let latestRecord = undefined;
     let publishedRecord = undefined;
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity
-    });
+    const entityBatch = entity.createEntityWriter();
     for (const record of records) {
       entityBatch.put({
         ...record,
-        ...updatedEntryMetaFields,
-        wbyDeleted: storageEntry.wbyDeleted,
-        location: storageEntry.location,
-        binOriginalFolderId: storageEntry.binOriginalFolderId
+        data: {
+          ...record.data,
+          ...updatedEntryMetaFields,
+          wbyDeleted: storageEntry.wbyDeleted,
+          location: storageEntry.location,
+          binOriginalFolderId: storageEntry.binOriginalFolderId
+        }
       });
 
       /**
        * We need to get the published and latest records, so we can update the Elasticsearch.
        */
       if (record.SK === publishedSortKey) {
-        publishedRecord = record;
+        publishedRecord = record.data;
       } else if (record.SK === latestSortKey) {
-        latestRecord = record;
+        latestRecord = record.data;
       }
     }
 
@@ -675,7 +582,7 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could mark as deleted all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
+      throw new WebinyError(ex.message || "Could mark as deleted all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -685,35 +592,32 @@ const createEntriesStorageOperations = params => {
     /**
      * We need to get the published and latest records from Elasticsearch.
      */
-    const esGetItems = [];
+    const esEntityReader = esEntity.createEntityReader();
     if (publishedRecord) {
-      esGetItems.push(esEntity.getBatch({
+      esEntityReader.get({
         PK: partitionKey,
         SK: publishedSortKey
-      }));
+      });
     }
     if (latestRecord) {
-      esGetItems.push(esEntity.getBatch({
+      esEntityReader.get({
         PK: partitionKey,
         SK: latestSortKey
-      }));
+      });
     }
-    if (esGetItems.length === 0) {
+    if (esEntityReader.total === 0) {
       return;
     }
-    const esRecords = await (0, _dbDynamodb.batchReadAll)({
-      table: esEntity.table,
-      items: esGetItems
-    });
+    const esRecords = await esEntityReader.execute();
     const esItems = (await Promise.all(esRecords.map(async record => {
       if (!record) {
         return null;
       }
       return {
         ...record,
-        data: await (0, _apiElasticsearch.decompress)(plugins, record.data)
+        data: await decompress(plugins, record.data)
       };
-    }))).filter(Boolean);
+    }))).filter(item => !!item);
     if (esItems.length === 0) {
       return;
     }
@@ -721,13 +625,11 @@ const createEntriesStorageOperations = params => {
     /**
      * We update all ES records with data received.
      */
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity
-    });
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
     for (const item of esItems) {
       elasticsearchEntityBatch.put({
         ...item,
-        data: await (0, _apiElasticsearch.compress)(plugins, {
+        data: await compress(plugins, {
           ...item.data,
           ...updatedEntryMetaFields,
           wbyDeleted: entry.wbyDeleted,
@@ -743,7 +645,7 @@ const createEntriesStorageOperations = params => {
     try {
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not mark as deleted entry records from DynamoDB Elasticsearch table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
+      throw new WebinyError(ex.message || "Could not mark as deleted entry records from DynamoDB Elasticsearch table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -756,7 +658,7 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const transformer = (0, _transformations.createTransformer)({
+    const transformer = createTransformer({
       plugins,
       model,
       entry: initialEntry,
@@ -770,10 +672,9 @@ const createEntriesStorageOperations = params => {
     /**
      * Let's pick the `restored` meta fields from the storage entry.
      */
-    const updatedEntryMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isRestoredEntryMetaField);
-    const partitionKey = (0, _keys.createPartitionKey)({
+    const updatedEntryMetaFields = pickEntryMetaFields(entry, isRestoredEntryMetaField);
+    const partitionKey = createPartitionKey({
       id: entry.id,
-      locale: model.locale,
       tenant: model.tenant
     });
 
@@ -781,40 +682,40 @@ const createEntriesStorageOperations = params => {
      * First we need to fetch all the records in the regular DynamoDB table.
      */
     const queryAllParams = {
-      entity,
       partitionKey,
       options: {
         gte: " "
       }
     };
-    const latestSortKey = (0, _keys.createLatestSortKey)();
-    const publishedSortKey = (0, _keys.createPublishedSortKey)();
-    const records = await (0, _dbDynamodb.queryAll)(queryAllParams);
+    const latestSortKey = createLatestSortKey();
+    const publishedSortKey = createPublishedSortKey();
+    const records = await entity.queryAll(queryAllParams);
 
     /**
      * Then update all the records with data received.
      */
     let latestRecord = undefined;
     let publishedRecord = undefined;
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity
-    });
+    const entityBatch = entity.createEntityWriter();
     for (const record of records) {
       entityBatch.put({
         ...record,
-        ...updatedEntryMetaFields,
-        wbyDeleted: storageEntry.wbyDeleted,
-        location: storageEntry.location,
-        binOriginalFolderId: storageEntry.binOriginalFolderId
+        data: {
+          ...record.data,
+          ...updatedEntryMetaFields,
+          wbyDeleted: storageEntry.wbyDeleted,
+          location: storageEntry.location,
+          binOriginalFolderId: storageEntry.binOriginalFolderId
+        }
       });
 
       /**
        * We need to get the published and latest records, so we can update the Elasticsearch.
        */
       if (record.SK === publishedSortKey) {
-        publishedRecord = record;
+        publishedRecord = record.data;
       } else if (record.SK === latestSortKey) {
-        latestRecord = record;
+        latestRecord = record.data;
       }
     }
 
@@ -827,7 +728,7 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not restore all entry records from in the DynamoDB table.", ex.code || "RESTORE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not restore all entry records from in the DynamoDB table.", ex.code || "RESTORE_ENTRY_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -837,32 +738,29 @@ const createEntriesStorageOperations = params => {
     /**
      * We need to get the published and latest records from Elasticsearch.
      */
-    const esGetItems = [];
+    const esEntityReader = esEntity.createEntityReader();
     if (publishedRecord) {
-      esGetItems.push(esEntity.getBatch({
+      esEntityReader.get({
         PK: partitionKey,
         SK: publishedSortKey
-      }));
+      });
     }
     if (latestRecord) {
-      esGetItems.push(esEntity.getBatch({
+      esEntityReader.get({
         PK: partitionKey,
         SK: latestSortKey
-      }));
+      });
     }
-    const esRecords = await (0, _dbDynamodb.batchReadAll)({
-      table: esEntity.table,
-      items: esGetItems
-    });
+    const esRecords = await esEntityReader.execute();
     const esItems = (await Promise.all(esRecords.map(async record => {
       if (!record) {
         return null;
       }
       return {
         ...record,
-        data: await (0, _apiElasticsearch.decompress)(plugins, record.data)
+        data: await decompress(plugins, record.data)
       };
-    }))).filter(Boolean);
+    }))).filter(item => !!item);
     if (esItems.length === 0) {
       return initialStorageEntry;
     }
@@ -870,13 +768,11 @@ const createEntriesStorageOperations = params => {
     /**
      * We update all ES records with data received.
      */
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity
-    });
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
     for (const item of esItems) {
       elasticsearchEntityBatch.put({
         ...item,
-        data: await (0, _apiElasticsearch.compress)(plugins, {
+        data: await compress(plugins, {
           ...item.data,
           ...updatedEntryMetaFields,
           wbyDeleted: entry.wbyDeleted,
@@ -892,7 +788,7 @@ const createEntriesStorageOperations = params => {
     try {
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not restore entry records from DynamoDB Elasticsearch table.", ex.code || "RESTORE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not restore entry records from DynamoDB Elasticsearch table.", ex.code || "RESTORE_ENTRY_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -906,27 +802,23 @@ const createEntriesStorageOperations = params => {
     } = params;
     const id = entry.id || entry.entryId;
     const model = getStorageOperationsModel(initialModel);
-    const partitionKey = (0, _keys.createPartitionKey)({
+    const partitionKey = createPartitionKey({
       id,
-      locale: model.locale,
       tenant: model.tenant
     });
-    const items = await (0, _dbDynamodb.queryAll)({
-      entity,
+    const items = await entity.queryAll({
       partitionKey,
       options: {
         gte: " "
       }
     });
-    const esItems = await (0, _dbDynamodb.queryAll)({
-      entity: esEntity,
+    const esItems = await esEntity.queryAll({
       partitionKey,
       options: {
         gte: " "
       }
     });
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity,
+    const entityBatch = entity.createEntityWriter({
       delete: items.map(item => {
         return {
           PK: item.PK,
@@ -934,8 +826,7 @@ const createEntriesStorageOperations = params => {
         };
       })
     });
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity,
+    const elasticsearchEntityBatch = esEntity.createEntityWriter({
       delete: esItems.map(item => {
         return {
           PK: item.PK,
@@ -949,7 +840,7 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not destroy entry records from DynamoDB table.", ex.code || "DELETE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not destroy entry records from DynamoDB table.", ex.code || "DELETE_ENTRY_ERROR", {
         error: ex,
         id
       });
@@ -957,7 +848,7 @@ const createEntriesStorageOperations = params => {
     try {
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not destroy entry records from DynamoDB Elasticsearch table.", ex.code || "DELETE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not destroy entry records from DynamoDB Elasticsearch table.", ex.code || "DELETE_ENTRY_ERROR", {
         error: ex,
         id
       });
@@ -970,14 +861,13 @@ const createEntriesStorageOperations = params => {
       latestStorageEntry: initialLatestStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const partitionKey = (0, _keys.createPartitionKey)({
+    const partitionKey = createPartitionKey({
       id: entry.id,
-      locale: model.locale,
       tenant: model.tenant
     });
     const {
       index
-    } = _configurations.configurations.es({
+    } = configurations.es({
       model
     });
     /**
@@ -990,16 +880,13 @@ const createEntriesStorageOperations = params => {
     /**
      * We need to delete all existing records of the given entry revision.
      */
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity,
+    const entityBatch = entity.createEntityWriter({
       delete: [{
         PK: partitionKey,
-        SK: (0, _keys.createRevisionSortKey)(entry)
+        SK: createRevisionSortKey(entry)
       }]
     });
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity
-    });
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
 
     /**
      * If revision we are deleting is the published one as well, we need to delete those records as well.
@@ -1007,11 +894,11 @@ const createEntriesStorageOperations = params => {
     if (publishedStorageEntry?.id === entry.id) {
       entityBatch.delete({
         PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
+        SK: createPublishedSortKey()
       });
       elasticsearchEntityBatch.delete({
         PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
+        SK: createPublishedSortKey()
       });
     }
     if (latestEntry && initialLatestStorageEntry) {
@@ -1023,37 +910,31 @@ const createEntriesStorageOperations = params => {
       /**
        * In the end we need to set the new latest entry.
        */
+      const latestStorageEntryLatestKey = createEntryLatestKeys(latestStorageEntry);
       entityBatch.put({
-        ...latestStorageEntry,
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: (0, _recordType.createLatestRecordType)()
+        ...latestStorageEntryLatestKey,
+        data: latestStorageEntry
       });
 
       /**
        * Also perform an update on the actual revision. This is needed
        * because of updates on the entry-level meta fields.
        */
+      const actualRevisionEntryKey = createEntryRevisionKeys(initialLatestStorageEntry);
       entityBatch.put({
-        ...latestStorageEntry,
-        PK: (0, _keys.createPartitionKey)({
-          id: initialLatestStorageEntry.id,
-          locale: model.locale,
-          tenant: model.tenant
-        }),
-        SK: (0, _keys.createRevisionSortKey)(initialLatestStorageEntry),
-        TYPE: (0, _recordType.createRecordType)()
+        ...actualRevisionEntryKey,
+        data: latestStorageEntry
       });
-      const latestTransformer = (0, _transformations.createTransformer)({
+      const latestTransformer = createTransformer({
         plugins,
         model,
         entry: latestEntry,
         storageEntry: initialLatestStorageEntry
       });
       const esLatestData = await latestTransformer.getElasticsearchLatestEntryData();
+      const esLatestKeys = createEntryLatestKeys(latestEntry);
       elasticsearchEntityBatch.put({
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
+        ...esLatestKeys,
         index,
         data: esLatestData
       });
@@ -1064,7 +945,7 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not batch write entry records to DynamoDB table.", ex.code || "DELETE_REVISION_ERROR", {
+      throw new WebinyError(ex.message || "Could not batch write entry records to DynamoDB table.", ex.code || "DELETE_REVISION_ERROR", {
         error: ex,
         entry,
         latestEntry,
@@ -1074,7 +955,7 @@ const createEntriesStorageOperations = params => {
     try {
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not batch write entry records to DynamoDB Elasticsearch table.", ex.code || "DELETE_REVISION_ERROR", {
+      throw new WebinyError(ex.message || "Could not batch write entry records to DynamoDB Elasticsearch table.", ex.code || "DELETE_REVISION_ERROR", {
         error: ex,
         entry,
         latestEntry,
@@ -1098,28 +979,22 @@ const createEntriesStorageOperations = params => {
      * Then we need to construct the queries for all the revisions and entries.
      */
 
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity
-    });
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity
-    });
+    const entityBatch = entity.createEntityWriter();
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
     for (const id of entries) {
       /**
        * Latest item.
        */
       entityBatch.delete({
-        PK: (0, _keys.createPartitionKey)({
+        PK: createPartitionKey({
           id,
-          locale: model.locale,
           tenant: model.tenant
         }),
         SK: "L"
       });
       elasticsearchEntityBatch.delete({
-        PK: (0, _keys.createPartitionKey)({
+        PK: createPartitionKey({
           id,
-          locale: model.locale,
           tenant: model.tenant
         }),
         SK: "L"
@@ -1129,17 +1004,15 @@ const createEntriesStorageOperations = params => {
        * Published item.
        */
       entityBatch.delete({
-        PK: (0, _keys.createPartitionKey)({
+        PK: createPartitionKey({
           id,
-          locale: model.locale,
           tenant: model.tenant
         }),
         SK: "P"
       });
       elasticsearchEntityBatch.delete({
-        PK: (0, _keys.createPartitionKey)({
+        PK: createPartitionKey({
           id,
-          locale: model.locale,
           tenant: model.tenant
         }),
         SK: "P"
@@ -1150,12 +1023,11 @@ const createEntriesStorageOperations = params => {
      */
     for (const revision of revisions) {
       entityBatch.delete({
-        PK: (0, _keys.createPartitionKey)({
+        PK: createPartitionKey({
           id: revision.id,
-          locale: model.locale,
           tenant: model.tenant
         }),
-        SK: (0, _keys.createRevisionSortKey)({
+        SK: createRevisionSortKey({
           version: revision.version
         })
       });
@@ -1165,18 +1037,18 @@ const createEntriesStorageOperations = params => {
   };
   const list = async (initialModel, params) => {
     const model = getStorageOperationsModel(initialModel);
-    const limit = (0, _apiElasticsearch.createLimit)(params.limit, 50);
+    const limit = createLimit(params.limit, 50);
     const {
       index
-    } = _configurations.configurations.es({
+    } = configurations.es({
       model
     });
-    const body = (0, _body.createElasticsearchBody)({
+    const body = createElasticsearchBody({
       model,
       params: {
         ...params,
         limit,
-        after: (0, _apiElasticsearch.decodeCursor)(params.after)
+        after: decodeCursor(params.after)
       },
       plugins
     });
@@ -1191,12 +1063,7 @@ const createEntriesStorageOperations = params => {
        * We will silently ignore the `index_not_found_exception` error and return an empty result set.
        * This is because the index might not exist yet, and we don't want to throw an error.
        */
-      if ((0, _shouldIgnoreEsResponseError.shouldIgnoreEsResponseError)(error)) {
-        (0, _logIgnoredEsResponseError.logIgnoredEsResponseError)({
-          error,
-          model,
-          indexName: index
-        });
+      if (shouldIgnoreEsResponseError(error)) {
         return {
           hasMoreItems: false,
           totalCount: 0,
@@ -1204,7 +1071,7 @@ const createEntriesStorageOperations = params => {
           items: []
         };
       }
-      throw new _error.default(error.message, error.code || "ELASTICSEARCH_ERROR", {
+      throw new WebinyError(error.message, error.code || "OPENSEARCH_ERROR", {
         error,
         index,
         body,
@@ -1215,12 +1082,14 @@ const createEntriesStorageOperations = params => {
       hits,
       total
     } = response?.body?.hits || {};
-    const items = (0, _helpers.extractEntriesFromIndex)({
+    const items = extractEntriesFromIndex({
       plugins,
       model,
-      entries: hits.map(item => item._source)
+      entries: hits.map(item => {
+        return item._source;
+      })
     }).map(item => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry: item
       });
@@ -1236,7 +1105,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, _apiElasticsearch.encodeCursor)(hits[items.length - 1].sort) || null : null;
+    const cursor = items.length > 0 ? encodeCursor(hits[items.length - 1].sort) || null : null;
     return {
       hasMoreItems,
       totalCount: total.value,
@@ -1260,7 +1129,7 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const transformer = (0, _transformations.createTransformer)({
+    const transformer = createTransformer({
       plugins,
       model,
       entry: initialEntry,
@@ -1270,45 +1139,21 @@ const createEntriesStorageOperations = params => {
       entry,
       storageEntry
     } = transformer.transformEntryKeys();
-    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 revisionKeys = createEntryRevisionKeys(entry);
+    const latestKeys = createEntryLatestKeys(entry);
+    const publishedKeys = createEntryPublishedKeys(entry);
     let latestEsEntry = null;
     try {
-      latestEsEntry = await (0, _dbDynamodb.getClean)({
-        entity: esEntity,
-        keys: latestKeys
-      });
+      latestEsEntry = await esEntity.getClean(latestKeys);
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not read Elasticsearch latest data.", ex.code || "PUBLISH_LATEST_READ", {
+      throw new WebinyError(ex.message || "Could not read Elasticsearch latest data.", ex.code || "PUBLISH_LATEST_READ", {
         error: ex,
         latestKeys: latestKeys,
         publishedKeys: publishedKeys
       });
     }
     if (!latestEsEntry) {
-      throw new _error.default(`Could not publish entry. Could not load latest ("L") record (ES table).`, "PUBLISH_ERROR", {
+      throw new WebinyError(`Could not publish entry. Could not load latest ("L") record (ES table).`, "PUBLISH_ERROR", {
         entry
       });
     }
@@ -1321,7 +1166,7 @@ const createEntriesStorageOperations = params => {
       ids: [entry.id]
     });
     if (!latestStorageEntry) {
-      throw new _error.default(`Could not publish entry. Could not load latest ("L") record.`, "PUBLISH_ERROR", {
+      throw new WebinyError(`Could not publish entry. Could not load latest ("L") record.`, "PUBLISH_ERROR", {
         entry
       });
     }
@@ -1335,24 +1180,19 @@ const createEntriesStorageOperations = params => {
     });
 
     // 1. Update REV# and P records with new data.
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity,
+    const entityBatch = entity.createEntityWriter({
       put: [{
-        ...storageEntry,
         ...revisionKeys,
-        TYPE: (0, _recordType.createRecordType)()
+        data: storageEntry
       }, {
-        ...storageEntry,
         ...publishedKeys,
-        TYPE: (0, _recordType.createPublishedRecordType)()
+        data: storageEntry
       }]
     });
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity
-    });
+    const elasticsearchEntityWriter = esEntity.createEntityWriter();
     const {
       index: esIndex
-    } = _configurations.configurations.es({
+    } = configurations.es({
       model
     });
 
@@ -1363,8 +1203,8 @@ const createEntriesStorageOperations = params => {
     if (publishingLatestRevision) {
       // 2.1 If we're publishing the latest revision, we first need to update the L record.
       entityBatch.put({
-        ...storageEntry,
-        ...latestKeys
+        ...latestKeys,
+        data: storageEntry
       });
 
       // 2.2 Additionally, if we have a previously published entry, we need to mark it as unpublished.
@@ -1377,12 +1217,13 @@ const createEntriesStorageOperations = params => {
           /**
            * Update currently published entry (unpublish it)
            */
+          const publishedStorageEntryKeys = createEntryRevisionKeys(publishedStorageEntry);
           entityBatch.put({
-            ...publishedStorageEntry,
-            status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
-            TYPE: (0, _recordType.createRecordType)(),
-            PK: (0, _keys.createPartitionKey)(publishedStorageEntry),
-            SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry)
+            ...publishedStorageEntryKeys,
+            data: {
+              ...publishedStorageEntry,
+              status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+            }
           });
         }
       }
@@ -1390,32 +1231,30 @@ const createEntriesStorageOperations = params => {
       // 2.3 If the published revision is not the latest one, the situation is a bit
       // more complex. We first need to update the L and REV# records with the new
       // values of *only entry-level* meta fields.
-      const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
+      const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
 
       // 2.4 Update L record. Apart from updating the entry-level meta fields, we also need
       //    to change the status from "published" to "unpublished" (if the status is set to "published").
       let latestRevisionStatus = latestStorageEntry.status;
-      if (latestRevisionStatus === _types.CONTENT_ENTRY_STATUS.PUBLISHED) {
-        latestRevisionStatus = _types.CONTENT_ENTRY_STATUS.UNPUBLISHED;
+      if (latestRevisionStatus === CONTENT_ENTRY_STATUS.PUBLISHED) {
+        latestRevisionStatus = CONTENT_ENTRY_STATUS.UNPUBLISHED;
       }
       const latestStorageEntryFields = {
         ...latestStorageEntry,
         ...updatedEntryLevelMetaFields,
         status: latestRevisionStatus
       };
+      const latestStorageEntryLatestKeys = createEntryLatestKeys(latestStorageEntry);
       entityBatch.put({
-        ...latestStorageEntryFields,
-        PK: (0, _keys.createPartitionKey)(latestStorageEntry),
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: (0, _recordType.createLatestRecordType)()
+        ...latestStorageEntryLatestKeys,
+        data: latestStorageEntryFields
       });
 
       // 2.5 Update REV# record.
+      const latestStorageEntryRevisionKeys = createEntryRevisionKeys(latestStorageEntry);
       entityBatch.put({
-        ...latestStorageEntryFields,
-        PK: (0, _keys.createPartitionKey)(latestStorageEntry),
-        SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
-        TYPE: (0, _recordType.createRecordType)()
+        ...latestStorageEntryRevisionKeys,
+        data: latestStorageEntryFields
       });
 
       // 2.6 Additionally, if we have a previously published entry, we need to mark it as unpublished.
@@ -1426,12 +1265,13 @@ const createEntriesStorageOperations = params => {
         const isRepublishing = publishedStorageEntry.id === entry.id;
         const publishedRevisionDifferentFromLatest = publishedRevisionId !== latestStorageEntry.id;
         if (!isRepublishing && publishedRevisionDifferentFromLatest) {
+          const publishedStorageEntryRevisionKeys = createEntryRevisionKeys(publishedStorageEntry);
           entityBatch.put({
-            ...publishedStorageEntry,
-            PK: (0, _keys.createPartitionKey)(publishedStorageEntry),
-            SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry),
-            TYPE: (0, _recordType.createRecordType)(),
-            status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED
+            ...publishedStorageEntryRevisionKeys,
+            data: {
+              ...publishedStorageEntry,
+              status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+            }
           });
         }
       }
@@ -1443,7 +1283,7 @@ const createEntriesStorageOperations = params => {
      * Update the published revision entry in ES.
      */
     const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
-    elasticsearchEntityBatch.put({
+    elasticsearchEntityWriter.put({
       ...publishedKeys,
       index: esIndex,
       data: esPublishedData
@@ -1455,47 +1295,44 @@ const createEntriesStorageOperations = params => {
      * 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);
+    const latestEsEntryDataDecompressed = await decompress(plugins, latestEsEntry.data);
     if (publishingLatestRevision) {
-      const updatedMetaFields = (0, _constants.pickEntryMetaFields)(entry);
-      const latestTransformer = (0, _transformations.createTransformer)({
+      const updatedMetaFields = pickEntryMetaFields(entry);
+      const latestTransformer = createTransformer({
         plugins,
         model,
         transformedToIndex: {
           ...latestEsEntryDataDecompressed,
-          status: _types.CONTENT_ENTRY_STATUS.PUBLISHED,
+          status: CONTENT_ENTRY_STATUS.PUBLISHED,
           locked: true,
           ...updatedMetaFields
         }
       });
-      elasticsearchEntityBatch.put({
+      const esEntryLatestKeys = createEntryLatestKeys(latestEsEntryDataDecompressed);
+      elasticsearchEntityWriter.put({
         index: esIndex,
-        PK: (0, _keys.createPartitionKey)(latestEsEntryDataDecompressed),
-        SK: (0, _keys.createLatestSortKey)(),
-        data: await latestTransformer.getElasticsearchLatestEntryData()
+        data: await latestTransformer.getElasticsearchLatestEntryData(),
+        ...esEntryLatestKeys
       });
     } else {
-      const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
+      const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
 
       /**
        * Update the Elasticsearch table to propagate changes to the Elasticsearch.
        */
-      const latestEsEntry = await (0, _dbDynamodb.getClean)({
-        entity: esEntity,
-        keys: latestKeys
-      });
+      const latestEsEntry = await esEntity.getClean(latestKeys);
       if (latestEsEntry) {
-        const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
+        const latestEsEntryDataDecompressed = await decompress(plugins, latestEsEntry.data);
         let latestRevisionStatus = latestEsEntryDataDecompressed.status;
-        if (latestRevisionStatus === _types.CONTENT_ENTRY_STATUS.PUBLISHED) {
-          latestRevisionStatus = _types.CONTENT_ENTRY_STATUS.UNPUBLISHED;
+        if (latestRevisionStatus === CONTENT_ENTRY_STATUS.PUBLISHED) {
+          latestRevisionStatus = CONTENT_ENTRY_STATUS.UNPUBLISHED;
         }
-        const updatedLatestEntry = await (0, _apiElasticsearch.compress)(plugins, {
+        const updatedLatestEntry = await compress(plugins, {
           ...latestEsEntryDataDecompressed,
           ...updatedEntryLevelMetaFields,
           status: latestRevisionStatus
         });
-        elasticsearchEntityBatch.put({
+        elasticsearchEntityWriter.put({
           ...latestKeys,
           index: esIndex,
           data: updatedLatestEntry
@@ -1512,7 +1349,7 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not store publish entry records in DynamoDB table.", ex.code || "PUBLISH_ERROR", {
+      throw new WebinyError(ex.message || "Could not store publish entry records in DynamoDB table.", ex.code || "PUBLISH_ERROR", {
         error: ex,
         entry,
         latestStorageEntry,
@@ -1523,9 +1360,9 @@ const createEntriesStorageOperations = params => {
      * And Elasticsearch table batch.
      */
     try {
-      await elasticsearchEntityBatch.execute();
+      await elasticsearchEntityWriter.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not store publish entry records in DynamoDB Elasticsearch table.", ex.code || "PUBLISH_ES_ERROR", {
+      throw new WebinyError(ex.message || "Could not store publish entry records in DynamoDB Elasticsearch table.", ex.code || "PUBLISH_ES_ERROR", {
         error: ex,
         entry,
         latestStorageEntry,
@@ -1540,7 +1377,7 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const transformer = (0, _transformations.createTransformer)({
+    const transformer = createTransformer({
       plugins,
       model,
       entry: initialEntry,
@@ -1558,29 +1395,25 @@ const createEntriesStorageOperations = params => {
       model,
       ids: [entry.id]
     });
-    const partitionKey = (0, _keys.createPartitionKey)({
+    const partitionKey = createPartitionKey({
       id: entry.id,
-      locale: model.locale,
       tenant: model.tenant
     });
-    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity,
+    const entryRevisionKeys = createEntryRevisionKeys(entry);
+    const entityBatch = entity.createEntityWriter({
       put: [{
-        ...storageEntry,
-        PK: partitionKey,
-        SK: (0, _keys.createRevisionSortKey)(entry),
-        TYPE: (0, _recordType.createRecordType)()
+        ...entryRevisionKeys,
+        data: storageEntry
       }],
       delete: [{
         PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
+        SK: createPublishedSortKey()
       }]
     });
-    const elasticsearchEntityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
-      entity: esEntity,
+    const elasticsearchEntityBatch = esEntity.createEntityWriter({
       delete: [{
         PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
+        SK: createPublishedSortKey()
       }]
     });
 
@@ -1590,21 +1423,19 @@ const createEntriesStorageOperations = params => {
     if (latestStorageEntry?.id === entry.id) {
       const {
         index
-      } = _configurations.configurations.es({
+      } = configurations.es({
         model
       });
+      const entryLatestKeys = createEntryLatestKeys(storageEntry);
       entityBatch.put({
-        ...storageEntry,
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: (0, _recordType.createLatestRecordType)()
+        ...entryLatestKeys,
+        data: storageEntry
       });
       const esLatestData = await transformer.getElasticsearchLatestEntryData();
       elasticsearchEntityBatch.put({
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
         index,
-        data: esLatestData
+        data: esLatestData,
+        ...entryLatestKeys
       });
     }
 
@@ -1617,7 +1448,7 @@ const createEntriesStorageOperations = params => {
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not store unpublished entry records in DynamoDB table.", ex.code || "UNPUBLISH_ERROR", {
+      throw new WebinyError(ex.message || "Could not store unpublished entry records in DynamoDB table.", ex.code || "UNPUBLISH_ERROR", {
         entry,
         storageEntry
       });
@@ -1628,7 +1459,7 @@ const createEntriesStorageOperations = params => {
     try {
       await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not store unpublished entry records in DynamoDB Elasticsearch table.", ex.code || "UNPUBLISH_ERROR", {
+      throw new WebinyError(ex.message || "Could not store unpublished entry records in DynamoDB Elasticsearch table.", ex.code || "UNPUBLISH_ERROR", {
         entry,
         storageEntry
       });
@@ -1644,7 +1475,7 @@ const createEntriesStorageOperations = params => {
     if (!entry) {
       return null;
     }
-    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+    return convertEntryKeysFromStorage({
       model,
       entry
     });
@@ -1658,7 +1489,7 @@ const createEntriesStorageOperations = params => {
     if (!entry) {
       return null;
     }
-    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+    return convertEntryKeysFromStorage({
       model,
       entry
     });
@@ -1672,7 +1503,7 @@ const createEntriesStorageOperations = params => {
     if (!entry) {
       return null;
     }
-    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+    return convertEntryKeysFromStorage({
       model,
       entry
     });
@@ -1684,7 +1515,7 @@ const createEntriesStorageOperations = params => {
       ids: [params.id]
     });
     return entries.map(entry => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry
       });
@@ -1697,7 +1528,7 @@ const createEntriesStorageOperations = params => {
       ids: params.ids
     });
     return entries.map(entry => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry
       });
@@ -1710,7 +1541,7 @@ const createEntriesStorageOperations = params => {
       ids: params.ids
     });
     return entries.map(entry => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry
       });
@@ -1723,7 +1554,7 @@ const createEntriesStorageOperations = params => {
       ids: params.ids
     });
     return entries.map(entry => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry
       });
@@ -1732,51 +1563,44 @@ const createEntriesStorageOperations = params => {
   const getPreviousRevision = async (initialModel, params) => {
     const model = getStorageOperationsModel(initialModel);
     const {
-      tenant,
-      locale
+      tenant
     } = 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
-      }
+    const partitionKey = createPartitionKey({
+      tenant,
+      id: entryId
+    });
+    const options = {
+      beginsWith: `REV#`,
+      reverse: true
     };
     try {
-      const result = await (0, _dbDynamodb.queryOne)(queryParams);
-      const entry = (0, _dbDynamodb.cleanupItem)(entity, result);
+      const unfilteredEntries = (await entity.queryAll({
+        partitionKey,
+        options
+      })).map(item => {
+        return item.data;
+      });
+      const entries = unfilteredEntries.filter(item => {
+        return item.version < version;
+      });
+      const entry = entries[0];
       if (!entry) {
         return null;
       }
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      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", {
+      throw new WebinyError(ex.message || "Could not get previous version of given entry.", ex.code || "GET_PREVIOUS_VERSION_ERROR", {
         ...params,
         error: ex,
-        partitionKey: queryParams.partitionKey,
-        options: queryParams.options,
+        partitionKey,
+        options,
         model
       });
     }
@@ -1788,10 +1612,10 @@ const createEntriesStorageOperations = params => {
     } = params;
     const {
       index
-    } = _configurations.configurations.es({
+    } = configurations.es({
       model
     });
-    const initialBody = (0, _body.createElasticsearchBody)({
+    const initialBody = createElasticsearchBody({
       model,
       params: {
         limit: 1,
@@ -1801,7 +1625,7 @@ const createEntriesStorageOperations = params => {
     });
     const field = model.fields.find(f => f.fieldId === fieldId);
     if (!field) {
-      throw new _error.default(`Could not find field with given "fieldId" value.`, "FIELD_NOT_FOUND", {
+      throw new WebinyError(`Could not find field with given "fieldId" value.`, "FIELD_NOT_FOUND", {
         fieldId
       });
     }
@@ -1827,15 +1651,10 @@ const createEntriesStorageOperations = params => {
         body
       });
     } catch (error) {
-      if ((0, _shouldIgnoreEsResponseError.shouldIgnoreEsResponseError)(error)) {
-        (0, _logIgnoredEsResponseError.logIgnoredEsResponseError)({
-          error,
-          model,
-          indexName: index
-        });
+      if (shouldIgnoreEsResponseError(error)) {
         return [];
       }
-      throw new _error.default(error.message || "Error in the Elasticsearch query.", error.code || "ELASTICSEARCH_ERROR", {
+      throw new WebinyError(error.message || "Error in the Elasticsearch query.", error.code || "OPENSEARCH_ERROR", {
         error,
         index,
         model,
@@ -1876,6 +1695,5 @@ const createEntriesStorageOperations = params => {
     dataLoaders
   };
 };
-exports.createEntriesStorageOperations = createEntriesStorageOperations;
 
 //# sourceMappingURL=index.js.map