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

package/operations/entry/index.js

@@ -1,43 +1,31 @@
-"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 _batchWrite = require("@webiny/db-dynamodb/utils/batchWrite");
-var _dataLoaders = require("./dataLoaders");
-var _keys = require("./keys");
-var _query = require("@webiny/db-dynamodb/utils/query");
-var _apiElasticsearch = require("@webiny/api-elasticsearch");
-var _get = require("@webiny/db-dynamodb/utils/get");
-var _utils = require("@webiny/utils");
-var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
-var _body = require("./elasticsearch/body");
-var _recordType = require("./recordType");
-var _apiHeadlessCms = require("@webiny/api-headless-cms");
-var _dbDynamodb = require("@webiny/db-dynamodb");
-var _transformations = require("./transformations");
-var _convertEntryKeys = require("./transformations/convertEntryKeys");
-var _constants = require("@webiny/api-headless-cms/constants");
-const IGNORED_ES_SEARCH_EXCEPTIONS = ["index_not_found_exception", "search_phase_execution_exception"];
-const shouldIgnoreElasticsearchException = ex => {
-  if (IGNORED_ES_SEARCH_EXCEPTIONS.includes(ex.message)) {
-    console.log(`Ignoring Elasticsearch exception: ${ex.message}`);
-    console.log({
-      code: ex.code,
-      data: ex.data,
-      stack: ex.stack
-    });
-    return true;
-  }
-  return false;
+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,
+    storageEntry
+  } = params;
+  const values = model.convertValueKeyToStorage({
+    fields: model.fields,
+    values: storageEntry.values
+  });
+  return {
+    ...storageEntry,
+    values
+  };
 };
-const createEntriesStorageOperations = params => {
+export const createEntriesStorageOperations = params => {
   const {
     entity,
     esEntity,
@@ -49,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) => {
@@ -69,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,
@@ -82,88 +70,68 @@ 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 items = [entity.putBatch({
-      ...storageEntry,
-      locked,
-      ...revisionKeys,
-      TYPE: (0, _recordType.createRecordType)()
-    }), entity.putBatch({
-      ...storageEntry,
-      locked,
-      ...latestKeys,
-      TYPE: (0, _recordType.createLatestRecordType)()
-    })];
+    const revisionKeys = createEntryRevisionKeys(entry);
+    const latestKeys = createEntryLatestKeys(entry);
+    const publishedKeys = createEntryPublishedKeys(entry);
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...revisionKeys,
+        data: {
+          ...storageEntry,
+          locked
+        }
+      }, {
+        ...latestKeys,
+        data: {
+          ...storageEntry,
+          locked
+        }
+      }]
+    });
     if (isPublished) {
-      items.push(entity.putBatch({
-        ...storageEntry,
-        locked,
+      entityBatch.put({
         ...publishedKeys,
-        TYPE: (0, _recordType.createPublishedRecordType)()
-      }));
+        data: {
+          ...storageEntry,
+          locked
+        }
+      });
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not 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 esItems = [esEntity.putBatch({
-      ...latestKeys,
-      index: esIndex,
-      data: esLatestData
-    })];
+    const elasticsearchEntityBatch = esEntity.createEntityWriter({
+      put: [{
+        ...latestKeys,
+        index: esIndex,
+        data: esLatestData
+      }]
+    });
     if (isPublished) {
       const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
-      esItems.push(esEntity.putBatch({
+      elasticsearchEntityBatch.put({
         ...publishedKeys,
         index: esIndex,
         data: esPublishedData
-      }));
+      });
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
+      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
@@ -177,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,
@@ -187,66 +155,80 @@ 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 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 items = [entity.putBatch({
-      ...storageEntry,
-      TYPE: (0, _recordType.createRecordType)(),
-      ...revisionKeys
-    }), entity.putBatch({
-      ...storageEntry,
-      TYPE: (0, _recordType.createLatestRecordType)(),
-      ...latestKeys
-    })];
-    const {
-      index
-    } = _configurations.configurations.es({
-      model
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...revisionKeys,
+        data: storageEntry
+      }, {
+        ...latestKeys,
+        data: storageEntry
+      }]
     });
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
+    if (isPublished) {
+      entityBatch.put({
+        ...publishedKeys,
+        data: storageEntry
       });
+
+      // Unpublish previously published revision (if any).
+      const [publishedRevisionStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+        model,
+        ids: [entry.id]
+      });
+      if (publishedRevisionStorageEntry) {
+        const publishedRevisionKey = createEntryRevisionKeys(publishedRevisionStorageEntry);
+        entityBatch.put({
+          ...publishedRevisionKey,
+          data: {
+            ...publishedRevisionStorageEntry,
+            status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+          }
+        });
+      }
+    }
+    try {
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not create revision from given entry in the DynamoDB table.", ex.code || "CREATE_REVISION_ERROR", {
+      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
       });
     }
-    /**
-     * Update the "latest" entry item in the Elasticsearch
-     */
-    try {
-      await (0, _dbDynamodb.put)({
-        entity: esEntity,
-        item: {
-          ...latestKeys,
-          index,
-          data: esLatestData
-        }
+    const {
+      index: esIndex
+    } = configurations.es({
+      model
+    });
+    const elasticsearchEntityBatch = esEntity.createEntityWriter({
+      put: [{
+        ...latestKeys,
+        index: esIndex,
+        data: esLatestData
+      }]
+    });
+    if (isPublished) {
+      const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
+      elasticsearchEntityBatch.put({
+        ...publishedKeys,
+        index: esIndex,
+        data: esPublishedData
       });
+    }
+    try {
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not update latest entry in the DynamoDB Elasticsearch table.", ex.code || "CREATE_REVISION_ERROR", {
+      throw new WebinyError(ex.message || "Could not update latest entry in the DynamoDB Elasticsearch table.", ex.code || "CREATE_REVISION_ERROR", {
         error: ex,
         entry
       });
@@ -262,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,
@@ -274,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.
@@ -310,24 +271,28 @@ const createEntriesStorageOperations = params => {
       model,
       ids: [entry.id]
     });
-    const items = [entity.putBatch({
-      ...storageEntry,
-      locked,
-      ...revisionKeys,
-      TYPE: (0, _recordType.createRecordType)()
-    })];
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...revisionKeys,
+        data: {
+          ...storageEntry,
+          locked
+        }
+      }]
+    });
     if (isPublished) {
-      items.push(entity.putBatch({
-        ...storageEntry,
-        locked,
+      entityBatch.put({
         ...publishedKeys,
-        TYPE: (0, _recordType.createPublishedRecordType)()
-      }));
+        data: {
+          ...storageEntry,
+          locked
+        }
+      });
     }
-    const esItems = [];
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
     const {
       index: esIndex
-    } = _configurations.configurations.es({
+    } = configurations.es({
       model
     });
 
@@ -340,31 +305,32 @@ const createEntriesStorageOperations = params => {
         /**
          * First we update the regular DynamoDB table.
          */
-        items.push(entity.putBatch({
-          ...storageEntry,
+        entityBatch.put({
           ...latestKeys,
-          TYPE: (0, _recordType.createLatestRecordType)()
-        }));
+          data: storageEntry
+        });
 
         /**
          * And then update the Elasticsearch table to propagate changes to the Elasticsearch
          */
         const elasticsearchLatestData = await transformer.getElasticsearchLatestEntryData();
-        esItems.push(esEntity.putBatch({
+        elasticsearchEntityBatch.put({
           ...latestKeys,
           index: esIndex,
           data: elasticsearchLatestData
-        }));
+        });
       } else {
         /**
          * If not updating latest revision, we still want to update the latest revision's
          * entry-level meta fields to match the current revision's entry-level meta fields.
          */
-        const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
+        const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
         const updatedLatestStorageEntry = {
-          ...latestStorageEntry,
           ...latestKeys,
-          ...updatedEntryLevelMetaFields
+          data: {
+            ...latestStorageEntry,
+            ...updatedEntryLevelMetaFields
+          }
         };
 
         /**
@@ -372,75 +338,60 @@ const createEntriesStorageOperations = params => {
          * - one for the actual revision record
          * - one for the latest record
          */
-        items.push(entity.putBatch({
+        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)()
-        }));
-        items.push(entity.putBatch({
-          ...updatedLatestStorageEntry,
-          TYPE: (0, _recordType.createLatestRecordType)()
-        }));
+          SK: createRevisionSortKey(latestStorageEntry)
+        });
+        entityBatch.put({
+          ...updatedLatestStorageEntry
+        });
 
         /**
          * Update the Elasticsearch table to propagate changes to the Elasticsearch.
          */
-        const latestEsEntry = await (0, _get.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
           });
-          esItems.push(esEntity.putBatch({
+          elasticsearchEntityBatch.put({
             ...latestKeys,
             index: esIndex,
             data: updatedLatestEntry
-          }));
+          });
         }
       }
     }
     if (isPublished && publishedStorageEntry?.id === entry.id) {
       const elasticsearchPublishedData = await transformer.getElasticsearchPublishedEntryData();
-      esItems.push(esEntity.putBatch({
+      elasticsearchEntityBatch.put({
         ...publishedKeys,
         index: esIndex,
         data: elasticsearchPublishedData
-      }));
+      });
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not update entry DynamoDB records.", ex.code || "UPDATE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not update entry DynamoDB records.", ex.code || "UPDATE_ENTRY_ERROR", {
         error: ex,
         entry,
         storageEntry
       });
     }
-    if (esItems.length === 0) {
-      return initialStorageEntry;
-    }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
+      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
       });
@@ -449,113 +400,107 @@ 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, _query.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 items = [];
+    const entityBatch = entity.createEntityWriter();
     for (const record of records) {
-      items.push(entity.putBatch({
+      entityBatch.put({
         ...record,
-        location: {
-          ...record?.location,
-          folderId
+        data: {
+          ...record.data,
+          location: {
+            ...record.data.location,
+            folderId
+          }
         }
-      }));
+      });
+
       /**
        * 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 {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         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 esUpdateItems = [];
-    for (const item of esItems) {
-      esUpdateItems.push(esEntity.putBatch({
-        ...item,
-        data: await (0, _apiElasticsearch.compress)(plugins, {
-          ...item.data,
-          location: {
-            ...item.data?.location,
-            folderId
-          }
-        })
-      }));
-    }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esUpdateItems
-      });
+      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
       });
@@ -567,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,
@@ -577,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
     });
 
@@ -587,42 +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, _query.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 items = [];
+    const entityBatch = entity.createEntityWriter();
     for (const record of records) {
-      items.push(entity.putBatch({
+      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;
       }
     }
 
@@ -630,15 +577,12 @@ const createEntriesStorageOperations = params => {
      * We write the records back to the primary DynamoDB table.
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could mark as deleted all entry records from in the DynamoDB table.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
+      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
@@ -648,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;
     }
@@ -684,30 +625,27 @@ const createEntriesStorageOperations = params => {
     /**
      * We update all ES records with data received.
      */
-    const esUpdateItems = [];
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
     for (const item of esItems) {
-      esUpdateItems.push(esEntity.putBatch({
+      elasticsearchEntityBatch.put({
         ...item,
-        data: await (0, _apiElasticsearch.compress)(plugins, {
+        data: await compress(plugins, {
           ...item.data,
           ...updatedEntryMetaFields,
           wbyDeleted: entry.wbyDeleted,
           location: entry.location,
           binOriginalFolderId: entry.binOriginalFolderId
         })
-      }));
+      });
     }
 
     /**
      * We write the records back to the primary DynamoDB Elasticsearch table.
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esUpdateItems
-      });
+      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
@@ -720,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,
@@ -734,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
     });
 
@@ -745,37 +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, _query.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 items = [];
+    const entityBatch = entity.createEntityWriter();
     for (const record of records) {
-      items.push(entity.putBatch({
+      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;
       }
     }
 
@@ -783,15 +723,12 @@ const createEntriesStorageOperations = params => {
      * We write the records back to the primary DynamoDB table.
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not 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
@@ -801,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;
     }
@@ -834,30 +768,27 @@ const createEntriesStorageOperations = params => {
     /**
      * We update all ES records with data received.
      */
-    const esUpdateItems = [];
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
     for (const item of esItems) {
-      esUpdateItems.push(esEntity.putBatch({
+      elasticsearchEntityBatch.put({
         ...item,
-        data: await (0, _apiElasticsearch.compress)(plugins, {
+        data: await compress(plugins, {
           ...item.data,
           ...updatedEntryMetaFields,
           wbyDeleted: entry.wbyDeleted,
           location: entry.location,
           binOriginalFolderId: entry.binOriginalFolderId
         })
-      }));
+      });
     }
 
     /**
      * We write the records back to the primary DynamoDB Elasticsearch table.
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esUpdateItems
-      });
+      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
@@ -871,58 +802,53 @@ 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, _query.queryAll)({
-      entity,
+    const items = await entity.queryAll({
       partitionKey,
       options: {
         gte: " "
       }
     });
-    const esItems = await (0, _query.queryAll)({
-      entity: esEntity,
+    const esItems = await esEntity.queryAll({
       partitionKey,
       options: {
         gte: " "
       }
     });
-    const deleteItems = items.map(item => {
-      return entity.deleteBatch({
-        PK: item.PK,
-        SK: item.SK
-      });
+    const entityBatch = entity.createEntityWriter({
+      delete: items.map(item => {
+        return {
+          PK: item.PK,
+          SK: item.SK
+        };
+      })
     });
-    const deleteEsItems = esItems.map(item => {
-      return esEntity.deleteBatch({
-        PK: item.PK,
-        SK: item.SK
-      });
+    const elasticsearchEntityBatch = esEntity.createEntityWriter({
+      delete: esItems.map(item => {
+        return {
+          PK: item.PK,
+          SK: item.SK
+        };
+      })
     });
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items: deleteItems
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not 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
       });
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: deleteEsItems
-      });
+      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
       });
@@ -932,17 +858,16 @@ const createEntriesStorageOperations = params => {
     const {
       entry,
       latestEntry,
-      latestStorageEntry
+      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
     });
     /**
@@ -955,98 +880,86 @@ const createEntriesStorageOperations = params => {
     /**
      * We need to delete all existing records of the given entry revision.
      */
-    const items = [
-    /**
-     * Delete records of given entry revision.
-     */
-    entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry)
-    })];
-    const esItems = [];
+    const entityBatch = entity.createEntityWriter({
+      delete: [{
+        PK: partitionKey,
+        SK: createRevisionSortKey(entry)
+      }]
+    });
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
 
     /**
      * If revision we are deleting is the published one as well, we need to delete those records as well.
      */
     if (publishedStorageEntry?.id === entry.id) {
-      items.push(entity.deleteBatch({
+      entityBatch.delete({
         PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
-      }));
-      esItems.push(entity.deleteBatch({
+        SK: createPublishedSortKey()
+      });
+      elasticsearchEntityBatch.delete({
         PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
-      }));
+        SK: createPublishedSortKey()
+      });
     }
-    if (latestEntry && latestStorageEntry) {
+    if (latestEntry && initialLatestStorageEntry) {
+      const latestStorageEntry = convertToStorageEntry({
+        storageEntry: initialLatestStorageEntry,
+        model
+      });
+
       /**
        * In the end we need to set the new latest entry.
        */
-      items.push(entity.putBatch({
-        ...latestStorageEntry,
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: (0, _recordType.createLatestRecordType)()
-      }));
+      const latestStorageEntryLatestKey = createEntryLatestKeys(latestStorageEntry);
+      entityBatch.put({
+        ...latestStorageEntryLatestKey,
+        data: latestStorageEntry
+      });
 
       /**
        * Also perform an update on the actual revision. This is needed
        * because of updates on the entry-level meta fields.
        */
-      items.push(entity.putBatch({
-        ...latestStorageEntry,
-        PK: (0, _keys.createPartitionKey)({
-          id: latestStorageEntry.id,
-          locale: model.locale,
-          tenant: model.tenant
-        }),
-        SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
-        TYPE: (0, _recordType.createRecordType)()
-      }));
-      const latestTransformer = (0, _transformations.createTransformer)({
+      const actualRevisionEntryKey = createEntryRevisionKeys(initialLatestStorageEntry);
+      entityBatch.put({
+        ...actualRevisionEntryKey,
+        data: latestStorageEntry
+      });
+      const latestTransformer = createTransformer({
         plugins,
         model,
         entry: latestEntry,
-        storageEntry: latestStorageEntry
+        storageEntry: initialLatestStorageEntry
       });
       const esLatestData = await latestTransformer.getElasticsearchLatestEntryData();
-      esItems.push(esEntity.putBatch({
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
+      const esLatestKeys = createEntryLatestKeys(latestEntry);
+      elasticsearchEntityBatch.put({
+        ...esLatestKeys,
         index,
         data: esLatestData
-      }));
+      });
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not 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,
-        latestStorageEntry
+        initialLatestStorageEntry
       });
     }
-    if (esItems.length === 0) {
-      return;
-    }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
+      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,
-        latestStorageEntry
+        initialLatestStorageEntry
       });
     }
   };
@@ -1065,86 +978,77 @@ const createEntriesStorageOperations = params => {
     /**
      * Then we need to construct the queries for all the revisions and entries.
      */
-    const items = [];
-    const esItems = [];
+
+    const entityBatch = entity.createEntityWriter();
+    const elasticsearchEntityBatch = esEntity.createEntityWriter();
     for (const id of entries) {
       /**
        * Latest item.
        */
-      items.push(entity.deleteBatch({
-        PK: (0, _keys.createPartitionKey)({
+      entityBatch.delete({
+        PK: createPartitionKey({
           id,
-          locale: model.locale,
           tenant: model.tenant
         }),
         SK: "L"
-      }));
-      esItems.push(esEntity.deleteBatch({
-        PK: (0, _keys.createPartitionKey)({
+      });
+      elasticsearchEntityBatch.delete({
+        PK: createPartitionKey({
           id,
-          locale: model.locale,
           tenant: model.tenant
         }),
         SK: "L"
-      }));
+      });
+
       /**
        * Published item.
        */
-      items.push(entity.deleteBatch({
-        PK: (0, _keys.createPartitionKey)({
+      entityBatch.delete({
+        PK: createPartitionKey({
           id,
-          locale: model.locale,
           tenant: model.tenant
         }),
         SK: "P"
-      }));
-      esItems.push(esEntity.deleteBatch({
-        PK: (0, _keys.createPartitionKey)({
+      });
+      elasticsearchEntityBatch.delete({
+        PK: createPartitionKey({
           id,
-          locale: model.locale,
           tenant: model.tenant
         }),
         SK: "P"
-      }));
+      });
     }
     /**
      * Exact revisions of all the entries
      */
     for (const revision of revisions) {
-      items.push(entity.deleteBatch({
-        PK: (0, _keys.createPartitionKey)({
+      entityBatch.delete({
+        PK: createPartitionKey({
           id: revision.id,
-          locale: model.locale,
           tenant: model.tenant
         }),
-        SK: (0, _keys.createRevisionSortKey)({
+        SK: createRevisionSortKey({
           version: revision.version
         })
-      }));
+      });
     }
-    await (0, _batchWrite.batchWriteAll)({
-      table: entity.table,
-      items
-    });
-    await (0, _batchWrite.batchWriteAll)({
-      table: esEntity.table,
-      items: esItems
-    });
+    await entityBatch.execute();
+    await elasticsearchEntityBatch.execute();
   };
   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
     });
@@ -1154,12 +1058,12 @@ const createEntriesStorageOperations = params => {
         index,
         body
       });
-    } catch (ex) {
+    } catch (error) {
       /**
        * We will silently ignore the `index_not_found_exception` error and return an empty result set.
        * This is because the index might not exist yet, and we don't want to throw an error.
        */
-      if (shouldIgnoreElasticsearchException(ex)) {
+      if (shouldIgnoreEsResponseError(error)) {
         return {
           hasMoreItems: false,
           totalCount: 0,
@@ -1167,8 +1071,8 @@ const createEntriesStorageOperations = params => {
           items: []
         };
       }
-      throw new _error.default(ex.message, ex.code || "ELASTICSEARCH_ERROR", {
-        error: ex,
+      throw new WebinyError(error.message, error.code || "OPENSEARCH_ERROR", {
+        error,
         index,
         body,
         model
@@ -1178,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
       });
@@ -1199,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,
@@ -1223,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,
@@ -1233,94 +1139,24 @@ const createEntriesStorageOperations = params => {
       entry,
       storageEntry
     } = transformer.transformEntryKeys();
-
-    /**
-     * We need currently published entry to check if need to remove it.
-     */
-    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
-      model,
-      ids: [entry.id]
-    });
-    const revisionKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createRevisionSortKey)(entry)
-    };
-    const latestKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createLatestSortKey)()
-    };
-    const publishedKeys = {
-      PK: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      SK: (0, _keys.createPublishedSortKey)()
-    };
+    const revisionKeys = createEntryRevisionKeys(entry);
+    const latestKeys = createEntryLatestKeys(entry);
+    const publishedKeys = createEntryPublishedKeys(entry);
     let latestEsEntry = null;
     try {
-      latestEsEntry = await (0, _get.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
       });
     }
-    const items = [entity.putBatch({
-      ...storageEntry,
-      ...revisionKeys,
-      TYPE: (0, _recordType.createRecordType)()
-    })];
-    const esItems = [];
-    const {
-      index: esIndex
-    } = _configurations.configurations.es({
-      model
-    });
-    if (publishedStorageEntry && publishedStorageEntry.id !== entry.id) {
-      /**
-       * If there is a `published` entry already, we need to set it to `unpublished`. We need to
-       * execute two updates: update the previously published entry's status and the published entry record.
-       * DynamoDB does not support `batchUpdate` - so here we load the previously published
-       * entry's data to update its status within a batch operation. If, hopefully,
-       * they introduce a true update batch operation, remove this `read` call.
-       */
-      const [previouslyPublishedEntry] = await dataLoaders.getRevisionById({
-        model,
-        ids: [publishedStorageEntry.id]
+    if (!latestEsEntry) {
+      throw new WebinyError(`Could not publish entry. Could not load latest ("L") record (ES table).`, "PUBLISH_ERROR", {
+        entry
       });
-      items.push(
-      /**
-       * Update currently published entry (unpublish it)
-       */
-      entity.putBatch({
-        ...previouslyPublishedEntry,
-        status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
-        TYPE: (0, _recordType.createRecordType)(),
-        PK: (0, _keys.createPartitionKey)(publishedStorageEntry),
-        SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry)
-      }));
     }
-    /**
-     * Update the helper item in DB with the new published entry
-     */
-    items.push(entity.putBatch({
-      ...storageEntry,
-      ...publishedKeys,
-      TYPE: (0, _recordType.createPublishedRecordType)()
-    }));
 
     /**
      * We need the latest entry to check if it needs to be updated as well in the Elasticsearch.
@@ -1329,113 +1165,191 @@ const createEntriesStorageOperations = params => {
       model,
       ids: [entry.id]
     });
-    if (latestStorageEntry?.id === entry.id) {
-      items.push(entity.putBatch({
-        ...storageEntry,
-        ...latestKeys
-      }));
+    if (!latestStorageEntry) {
+      throw new WebinyError(`Could not publish entry. Could not load latest ("L") record.`, "PUBLISH_ERROR", {
+        entry
+      });
     }
-    if (latestEsEntry) {
-      const publishingLatestRevision = latestStorageEntry?.id === entry.id;
 
-      /**
-       * Need to decompress the data from Elasticsearch DynamoDB table.
-       *
-       * No need to transform it for the storage because it was fetched
-       * directly from the Elasticsearch table, where it sits transformed.
-       */
-      const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
-      if (publishingLatestRevision) {
-        const updatedMetaFields = (0, _constants.pickEntryMetaFields)(entry);
-        const latestTransformer = (0, _transformations.createTransformer)({
-          plugins,
-          model,
-          transformedToIndex: {
-            ...latestEsEntryDataDecompressed,
-            status: _types.CONTENT_ENTRY_STATUS.PUBLISHED,
-            locked: true,
-            ...updatedMetaFields
-          }
-        });
-        esItems.push(esEntity.putBatch({
-          index: esIndex,
-          PK: (0, _keys.createPartitionKey)(latestEsEntryDataDecompressed),
-          SK: (0, _keys.createLatestSortKey)(),
-          data: await latestTransformer.getElasticsearchLatestEntryData()
-        }));
-      } else {
-        const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
-        const updatedLatestStorageEntry = {
-          ...latestStorageEntry,
-          ...latestKeys,
-          ...updatedEntryLevelMetaFields
-        };
+    /**
+     * We need currently published entry to check if need to remove it.
+     */
+    const [publishedStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [entry.id]
+    });
 
-        /**
-         * First we update the regular DynamoDB table. Two updates are needed:
-         * - one for the actual revision record
-         * - one for the latest record
-         */
-        items.push(entity.putBatch({
-          ...updatedLatestStorageEntry,
-          PK: (0, _keys.createPartitionKey)({
-            id: latestStorageEntry.id,
-            locale: model.locale,
-            tenant: model.tenant
-          }),
-          SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
-          TYPE: (0, _recordType.createRecordType)()
-        }));
-        items.push(entity.putBatch({
-          ...updatedLatestStorageEntry,
-          TYPE: (0, _recordType.createLatestRecordType)()
-        }));
+    // 1. Update REV# and P records with new data.
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...revisionKeys,
+        data: storageEntry
+      }, {
+        ...publishedKeys,
+        data: storageEntry
+      }]
+    });
+    const elasticsearchEntityWriter = esEntity.createEntityWriter();
+    const {
+      index: esIndex
+    } = configurations.es({
+      model
+    });
 
-        /**
-         * Update the Elasticsearch table to propagate changes to the Elasticsearch.
-         */
-        const latestEsEntry = await (0, _get.getClean)({
-          entity: esEntity,
-          keys: latestKeys
-        });
-        if (latestEsEntry) {
-          const latestEsEntryDataDecompressed = await (0, _apiElasticsearch.decompress)(plugins, latestEsEntry.data);
-          const updatedLatestEntry = await (0, _apiElasticsearch.compress)(plugins, {
-            ...latestEsEntryDataDecompressed,
-            ...updatedEntryLevelMetaFields
+    // 2. When it comes to the latest record, we need to perform a couple of different
+    // updates, based on whether the entry being published is the latest revision or not.
+    const publishedRevisionId = publishedStorageEntry?.id;
+    const publishingLatestRevision = latestStorageEntry?.id === entry.id;
+    if (publishingLatestRevision) {
+      // 2.1 If we're publishing the latest revision, we first need to update the L record.
+      entityBatch.put({
+        ...latestKeys,
+        data: storageEntry
+      });
+
+      // 2.2 Additionally, if we have a previously published entry, we need to mark it as unpublished.
+      //     Note that we need to take re-publishing into account (same published revision being
+      //     published again), in which case the below code does not apply. This is because the
+      //     required updates were already applied above.
+      if (publishedStorageEntry) {
+        const isRepublishing = publishedStorageEntry.id === entry.id;
+        if (!isRepublishing) {
+          /**
+           * Update currently published entry (unpublish it)
+           */
+          const publishedStorageEntryKeys = createEntryRevisionKeys(publishedStorageEntry);
+          entityBatch.put({
+            ...publishedStorageEntryKeys,
+            data: {
+              ...publishedStorageEntry,
+              status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+            }
+          });
+        }
+      }
+    } else {
+      // 2.3 If the published revision is not the latest one, the situation is a bit
+      // more complex. We first need to update the L and REV# records with the new
+      // values of *only entry-level* meta fields.
+      const updatedEntryLevelMetaFields = 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 === CONTENT_ENTRY_STATUS.PUBLISHED) {
+        latestRevisionStatus = CONTENT_ENTRY_STATUS.UNPUBLISHED;
+      }
+      const latestStorageEntryFields = {
+        ...latestStorageEntry,
+        ...updatedEntryLevelMetaFields,
+        status: latestRevisionStatus
+      };
+      const latestStorageEntryLatestKeys = createEntryLatestKeys(latestStorageEntry);
+      entityBatch.put({
+        ...latestStorageEntryLatestKeys,
+        data: latestStorageEntryFields
+      });
+
+      // 2.5 Update REV# record.
+      const latestStorageEntryRevisionKeys = createEntryRevisionKeys(latestStorageEntry);
+      entityBatch.put({
+        ...latestStorageEntryRevisionKeys,
+        data: latestStorageEntryFields
+      });
+
+      // 2.6 Additionally, if we have a previously published entry, we need to mark it as unpublished.
+      //     Note that we need to take re-publishing into account (same published revision being
+      //     published again), in which case the below code does not apply. This is because the
+      //     required updates were already applied above.
+      if (publishedStorageEntry) {
+        const isRepublishing = publishedStorageEntry.id === entry.id;
+        const publishedRevisionDifferentFromLatest = publishedRevisionId !== latestStorageEntry.id;
+        if (!isRepublishing && publishedRevisionDifferentFromLatest) {
+          const publishedStorageEntryRevisionKeys = createEntryRevisionKeys(publishedStorageEntry);
+          entityBatch.put({
+            ...publishedStorageEntryRevisionKeys,
+            data: {
+              ...publishedStorageEntry,
+              status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+            }
           });
-          esItems.push(esEntity.putBatch({
-            ...latestKeys,
-            index: esIndex,
-            data: updatedLatestEntry
-          }));
         }
       }
     }
 
+    // 3. Update records in ES -> DDB table.
+
     /**
      * Update the published revision entry in ES.
      */
     const esPublishedData = await transformer.getElasticsearchPublishedEntryData();
-    esItems.push(esEntity.putBatch({
+    elasticsearchEntityWriter.put({
       ...publishedKeys,
       index: esIndex,
       data: esPublishedData
-    }));
+    });
+
+    /**
+     * 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 decompress(plugins, latestEsEntry.data);
+    if (publishingLatestRevision) {
+      const updatedMetaFields = pickEntryMetaFields(entry);
+      const latestTransformer = createTransformer({
+        plugins,
+        model,
+        transformedToIndex: {
+          ...latestEsEntryDataDecompressed,
+          status: CONTENT_ENTRY_STATUS.PUBLISHED,
+          locked: true,
+          ...updatedMetaFields
+        }
+      });
+      const esEntryLatestKeys = createEntryLatestKeys(latestEsEntryDataDecompressed);
+      elasticsearchEntityWriter.put({
+        index: esIndex,
+        data: await latestTransformer.getElasticsearchLatestEntryData(),
+        ...esEntryLatestKeys
+      });
+    } else {
+      const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
+
+      /**
+       * Update the Elasticsearch table to propagate changes to the Elasticsearch.
+       */
+      const latestEsEntry = await esEntity.getClean(latestKeys);
+      if (latestEsEntry) {
+        const latestEsEntryDataDecompressed = await decompress(plugins, latestEsEntry.data);
+        let latestRevisionStatus = latestEsEntryDataDecompressed.status;
+        if (latestRevisionStatus === CONTENT_ENTRY_STATUS.PUBLISHED) {
+          latestRevisionStatus = CONTENT_ENTRY_STATUS.UNPUBLISHED;
+        }
+        const updatedLatestEntry = await compress(plugins, {
+          ...latestEsEntryDataDecompressed,
+          ...updatedEntryLevelMetaFields,
+          status: latestRevisionStatus
+        });
+        elasticsearchEntityWriter.put({
+          ...latestKeys,
+          index: esIndex,
+          data: updatedLatestEntry
+        });
+      }
+    }
 
     /**
      * Finally, execute regular table batch.
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not 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,
@@ -1446,12 +1360,9 @@ const createEntriesStorageOperations = params => {
      * And Elasticsearch table batch.
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
+      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,
@@ -1466,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,
@@ -1484,61 +1395,60 @@ 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 items = [entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createPublishedSortKey)()
-    }), entity.putBatch({
-      ...storageEntry,
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      TYPE: (0, _recordType.createRecordType)()
-    })];
-    const esItems = [esEntity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createPublishedSortKey)()
-    })];
+    const entryRevisionKeys = createEntryRevisionKeys(entry);
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...entryRevisionKeys,
+        data: storageEntry
+      }],
+      delete: [{
+        PK: partitionKey,
+        SK: createPublishedSortKey()
+      }]
+    });
+    const elasticsearchEntityBatch = esEntity.createEntityWriter({
+      delete: [{
+        PK: partitionKey,
+        SK: createPublishedSortKey()
+      }]
+    });
+
     /**
      * If we are unpublishing the latest revision, let's also update the latest revision entry's status in both DynamoDB tables.
      */
     if (latestStorageEntry?.id === entry.id) {
       const {
         index
-      } = _configurations.configurations.es({
+      } = configurations.es({
         model
       });
-      items.push(entity.putBatch({
-        ...storageEntry,
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: (0, _recordType.createLatestRecordType)()
-      }));
+      const entryLatestKeys = createEntryLatestKeys(storageEntry);
+      entityBatch.put({
+        ...entryLatestKeys,
+        data: storageEntry
+      });
       const esLatestData = await transformer.getElasticsearchLatestEntryData();
-      esItems.push(esEntity.putBatch({
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
+      elasticsearchEntityBatch.put({
         index,
-        data: esLatestData
-      }));
+        data: esLatestData,
+        ...entryLatestKeys
+      });
     }
 
     /**
      * Finally, execute regular table batch.
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not 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
       });
@@ -1547,12 +1457,9 @@ const createEntriesStorageOperations = params => {
      * And Elasticsearch table batch.
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: esEntity.table,
-        items: esItems
-      });
+      await elasticsearchEntityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not store unpublished entry records in DynamoDB Elasticsearch table.", ex.code || "UNPUBLISH_ERROR", {
+      throw new WebinyError(ex.message || "Could not store unpublished entry records in DynamoDB Elasticsearch table.", ex.code || "UNPUBLISH_ERROR", {
         entry,
         storageEntry
       });
@@ -1568,7 +1475,7 @@ const createEntriesStorageOperations = params => {
     if (!entry) {
       return null;
     }
-    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+    return convertEntryKeysFromStorage({
       model,
       entry
     });
@@ -1582,7 +1489,7 @@ const createEntriesStorageOperations = params => {
     if (!entry) {
       return null;
     }
-    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+    return convertEntryKeysFromStorage({
       model,
       entry
     });
@@ -1596,7 +1503,7 @@ const createEntriesStorageOperations = params => {
     if (!entry) {
       return null;
     }
-    return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+    return convertEntryKeysFromStorage({
       model,
       entry
     });
@@ -1608,7 +1515,7 @@ const createEntriesStorageOperations = params => {
       ids: [params.id]
     });
     return entries.map(entry => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry
       });
@@ -1621,7 +1528,7 @@ const createEntriesStorageOperations = params => {
       ids: params.ids
     });
     return entries.map(entry => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry
       });
@@ -1634,7 +1541,7 @@ const createEntriesStorageOperations = params => {
       ids: params.ids
     });
     return entries.map(entry => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry
       });
@@ -1647,7 +1554,7 @@ const createEntriesStorageOperations = params => {
       ids: params.ids
     });
     return entries.map(entry => {
-      return (0, _convertEntryKeys.convertEntryKeysFromStorage)({
+      return convertEntryKeysFromStorage({
         model,
         entry
       });
@@ -1656,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, _query.queryOne)(queryParams);
-      const entry = (0, _cleanup.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
       });
     }
@@ -1712,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,
@@ -1725,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
       });
     }
@@ -1750,12 +1650,12 @@ const createEntriesStorageOperations = params => {
         index,
         body
       });
-    } catch (ex) {
-      if (shouldIgnoreElasticsearchException(ex)) {
+    } catch (error) {
+      if (shouldIgnoreEsResponseError(error)) {
         return [];
       }
-      throw new _error.default(ex.message || "Error in the Elasticsearch query.", ex.code || "ELASTICSEARCH_ERROR", {
-        error: ex,
+      throw new WebinyError(error.message || "Error in the Elasticsearch query.", error.code || "OPENSEARCH_ERROR", {
+        error,
         index,
         model,
         body
@@ -1795,6 +1695,5 @@ const createEntriesStorageOperations = params => {
     dataLoaders
   };
 };
-exports.createEntriesStorageOperations = createEntriesStorageOperations;
 
 //# sourceMappingURL=index.js.map