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

package/operations/entry/index.js

@@ -1,32 +1,13 @@
-"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 _dataLoaders = require("./dataLoaders");
-var _types = require("@webiny/api-headless-cms/types");
-var _keys = require("./keys");
-var _batchWrite = require("@webiny/db-dynamodb/utils/batchWrite");
-var _query = require("@webiny/db-dynamodb/utils/query");
-var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
-var _cursor = require("@webiny/utils/cursor");
-var _zeroPad = require("@webiny/utils/zeroPad");
-var _apiHeadlessCms = require("@webiny/api-headless-cms");
-var _createFields = require("./filtering/createFields");
-var _filtering = require("./filtering");
-var _constants = require("@webiny/api-headless-cms/constants");
-const createType = () => {
-  return "cms.entry";
-};
-const createLatestType = () => {
-  return `${createType()}.l`;
-};
-const createPublishedType = () => {
-  return `${createType()}.p`;
-};
+import WebinyError from "@webiny/error";
+import { DataLoadersHandler } from "./dataLoaders.js";
+import { CONTENT_ENTRY_STATUS } from "@webiny/api-headless-cms/types/index.js";
+import { createEntryLatestKeys, createEntryPublishedKeys, createEntryRevisionKeys, createGSIPartitionKey, createPartitionKey, createPublishedSortKey, createRevisionSortKey } from "./keys.js";
+import { decodeCursor, encodeCursor } from "@webiny/utils";
+import { StorageOperationsCmsModelPlugin, StorageTransformPlugin } from "@webiny/api-headless-cms";
+import { createFields } from "./filtering/createFields.js";
+import { filter, sort } from "./filtering/index.js";
+import { isDeletedEntryMetaField, isEntryLevelEntryMetaField, isRestoredEntryMetaField, pickEntryMetaFields } from "@webiny/api-headless-cms/constants.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
 const convertToStorageEntry = params => {
   const {
     model,
@@ -55,8 +36,8 @@ const convertFromStorageEntry = params => {
     values
   };
 };
-const MAX_LIST_LIMIT = 10000;
-const createEntriesStorageOperations = params => {
+const MAX_LIST_LIMIT = 1000000;
+export const createEntriesStorageOperations = params => {
   const {
     entity,
     plugins
@@ -66,23 +47,25 @@ 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 storageTransformPlugins = plugins.byType(_apiHeadlessCms.StorageTransformPlugin.type).reduce((collection, plugin) => {
-    collection[plugin.fieldType] = plugin;
-    return collection;
-  }, {});
   const createStorageTransformCallable = model => {
+    // Cache StorageTransformPlugin to optimize execution.
+    const storageTransformPlugins = plugins.byType(StorageTransformPlugin.type).reduce((collection, plugin) => {
+      collection[plugin.fieldType] = plugin;
+      return collection;
+    }, {});
     return (field, value) => {
-      const plugin = storageTransformPlugins[field.type];
+      const fieldType = getBaseFieldType(field);
+      const plugin = storageTransformPlugins[fieldType];
       if (!plugin) {
         return value;
       }
@@ -103,64 +86,55 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const partitionKey = (0, _keys.createPartitionKey)({
-      id: entry.id,
-      locale: model.locale,
-      tenant: model.tenant
-    });
     const isPublished = entry.status === "published";
     const locked = isPublished ? true : entry.locked;
     const storageEntry = convertToStorageEntry({
       model,
       storageEntry: initialStorageEntry
     });
+    const storageEntryRevisionKeys = createEntryRevisionKeys(entry);
+    const storageEntryLatestKeys = createEntryLatestKeys(entry);
     /**
      * We need to:
      *  - create new main entry item
      *  - create new or update the latest entry item
      */
-    const items = [entity.putBatch({
-      ...storageEntry,
-      locked,
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      TYPE: createType(),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-      GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-    }), entity.putBatch({
-      ...storageEntry,
-      locked,
-      PK: partitionKey,
-      SK: (0, _keys.createLatestSortKey)(),
-      TYPE: createLatestType(),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-      GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-    })];
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...storageEntryRevisionKeys,
+        data: {
+          ...storageEntry,
+          locked
+        }
+      }, {
+        ...storageEntryLatestKeys,
+        data: {
+          ...storageEntry,
+          locked
+        }
+      }]
+    });
 
     /**
      * We need to create published entry if
      */
     if (isPublished) {
-      items.push(entity.putBatch({
-        ...storageEntry,
-        locked,
-        PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)(),
-        TYPE: createLatestType(),
-        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
-        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-      }));
+      const storageEntryPublishedKeys = createEntryPublishedKeys(storageEntry);
+      entityBatch.put({
+        ...storageEntryPublishedKeys,
+        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 data into the DynamoDB.", ex.code || "CREATE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not insert data into the DynamoDB.", ex.code || "CREATE_ENTRY_ERROR", {
         error: ex,
         entry
       });
@@ -173,45 +147,63 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const partitionKey = (0, _keys.createPartitionKey)({
-      id: entry.id,
-      locale: model.locale,
-      tenant: model.tenant
-    });
     const storageEntry = convertToStorageEntry({
       storageEntry: initialStorageEntry,
       model
     });
+
     /**
      * We need to:
      *  - create the main entry item
-     *  - update the last entry item to a current one
+     *  - update the latest entry item to the current one
+     *  - if the entry's status was set to "published":
+     *      - update the published entry item to the current one
+     *      - unpublish previously published revision (if any)
      */
-    const items = [entity.putBatch({
-      ...storageEntry,
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(storageEntry),
-      TYPE: createType(),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-      GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-    }), entity.putBatch({
-      ...storageEntry,
-      PK: partitionKey,
-      SK: (0, _keys.createLatestSortKey)(),
-      TYPE: createLatestType(),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-      GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-    })];
-    try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...createEntryRevisionKeys(storageEntry),
+        data: {
+          ...storageEntry
+        }
+      }, {
+        ...createEntryLatestKeys(storageEntry),
+        data: {
+          ...storageEntry
+        }
+      }]
+    });
+    const isPublished = entry.status === "published";
+    if (isPublished) {
+      entityBatch.put({
+        ...createEntryPublishedKeys(storageEntry),
+        data: {
+          ...storageEntry
+        }
       });
+
+      // Unpublish previously published revision (if any).
+      const [publishedRevisionStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
+        model,
+        ids: [entry.id]
+      });
+      if (publishedRevisionStorageEntry) {
+        entityBatch.put({
+          ...createEntryRevisionKeys(publishedRevisionStorageEntry),
+          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.", ex.code || "CREATE_REVISION_ERROR", {
+      throw new WebinyError(ex.message || "Could not create revision from given entry.", ex.code || "CREATE_REVISION_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -228,14 +220,8 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const partitionKey = (0, _keys.createPartitionKey)({
-      id: entry.id,
-      locale: model.locale,
-      tenant: model.tenant
-    });
     const isPublished = entry.status === "published";
     const locked = isPublished ? true : entry.locked;
-    const items = [];
     const storageEntry = convertToStorageEntry({
       model,
       storageEntry: initialStorageEntry
@@ -245,25 +231,24 @@ const createEntriesStorageOperations = params => {
      *  - update the current entry
      *  - update the latest entry if the current entry is the latest one
      */
-    items.push(entity.putBatch({
-      ...storageEntry,
-      locked,
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(storageEntry),
-      TYPE: createType(),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-      GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-    }));
+
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...createEntryRevisionKeys(storageEntry),
+        data: {
+          ...storageEntry,
+          locked
+        }
+      }]
+    });
     if (isPublished) {
-      items.push(entity.putBatch({
-        ...storageEntry,
-        locked,
-        PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)(),
-        TYPE: createPublishedType(),
-        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
-        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-      }));
+      entityBatch.put({
+        ...createEntryPublishedKeys(storageEntry),
+        data: {
+          ...storageEntry,
+          locked
+        }
+      });
     }
 
     /**
@@ -273,58 +258,49 @@ const createEntriesStorageOperations = params => {
     if (latestStorageEntry) {
       const updatingLatestRevision = latestStorageEntry.id === entry.id;
       if (updatingLatestRevision) {
-        items.push(entity.putBatch({
-          ...storageEntry,
-          locked,
-          PK: partitionKey,
-          SK: (0, _keys.createLatestSortKey)(),
-          TYPE: createLatestType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-          GSI1_SK: (0, _keys.createGSISortKey)(entry)
-        }));
+        entityBatch.put({
+          ...createEntryLatestKeys(storageEntry),
+          data: {
+            ...storageEntry,
+            locked
+          }
+        });
       } 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);
 
         /**
          * 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({
-          ...latestStorageEntry,
-          ...updatedEntryLevelMetaFields,
-          PK: partitionKey,
-          SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
-          TYPE: createType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-          GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
-        items.push(entity.putBatch({
-          ...latestStorageEntry,
-          ...updatedEntryLevelMetaFields,
-          PK: partitionKey,
-          SK: (0, _keys.createLatestSortKey)(),
-          TYPE: createLatestType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-          GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
+        entityBatch.put({
+          ...createEntryRevisionKeys(latestStorageEntry),
+          data: {
+            ...latestStorageEntry,
+            ...updatedEntryLevelMetaFields
+          }
+        });
+        entityBatch.put({
+          ...createEntryLatestKeys(latestStorageEntry),
+          data: {
+            ...latestStorageEntry,
+            ...updatedEntryLevelMetaFields
+          }
+        });
       }
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
       return initialStorageEntry;
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not update entry.", ex.code || "UPDATE_ERROR", {
+      throw new WebinyError(ex.message || "Could not update entry.", ex.code || "UPDATE_ERROR", {
         error: ex,
         entry,
         latestStorageEntry
@@ -341,40 +317,41 @@ const createEntriesStorageOperations = params => {
     /**
      * First we need to load all the revisions and published / latest entry.
      */
-    const queryAllParams = {
-      entity,
-      partitionKey: (0, _keys.createPartitionKey)({
-        id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
+    const partitionKey = createPartitionKey({
+      id,
+      tenant: model.tenant
+    });
+    const records = await entity.queryAll({
+      partitionKey,
       options: {
         gte: " "
       }
-    };
-    const records = await (0, _query.queryAll)(queryAllParams);
+    });
     /**
      * Then create the batch writes for the DynamoDB, with the updated folderId.
      */
-    const items = records.map(item => {
-      return entity.putBatch({
-        ...item,
-        location: {
-          ...item.location,
-          folderId
-        }
-      });
+    const entityBatch = entity.createEntityWriter({
+      put: records.map(item => {
+        return {
+          ...item,
+          data: {
+            ...item.data,
+            location: {
+              ...item.data.location,
+              folderId
+            }
+          }
+        };
+      })
     });
+
     /**
      * And finally write it...
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
     } catch (ex) {
-      throw _error.default.from(ex, {
+      throw WebinyError.from(ex, {
         message: "Could not move records to a new folder.",
         data: {
           id,
@@ -393,26 +370,27 @@ const createEntriesStorageOperations = params => {
     /**
      * First we need to load all the revisions and published / latest entries.
      */
-    const queryAllParams = {
-      entity,
-      partitionKey: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      options: {
-        gte: " "
-      }
-    };
+
     let records = [];
     try {
-      records = await (0, _query.queryAll)(queryAllParams);
+      records = await entity.queryAll({
+        partitionKey: createPartitionKey({
+          id: entry.id,
+          tenant: model.tenant
+        }),
+        options: {
+          gte: " "
+        }
+      });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
+      throw new WebinyError(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
         error: ex,
         id: entry.id
       });
     }
+    if (records.length === 0) {
+      return;
+    }
     const storageEntry = convertToStorageEntry({
       model,
       storageEntry: initialStorageEntry
@@ -421,30 +399,32 @@ const createEntriesStorageOperations = params => {
     /**
      * Let's pick the `deleted` meta fields from the storage entry.
      */
-    const updatedDeletedMetaFields = (0, _constants.pickEntryMetaFields)(storageEntry, _constants.isDeletedEntryMetaField);
+    const updatedDeletedMetaFields = pickEntryMetaFields(storageEntry, isDeletedEntryMetaField);
 
     /**
      * Then create the batch writes for the DynamoDB, with the updated data.
      */
-    const items = records.map(record => {
-      return entity.putBatch({
-        ...record,
-        ...updatedDeletedMetaFields,
-        wbyDeleted: storageEntry.wbyDeleted,
-        location: storageEntry.location,
-        binOriginalFolderId: storageEntry.binOriginalFolderId
-      });
+    const entityBatch = entity.createEntityWriter({
+      put: records.map(record => {
+        return {
+          ...record,
+          data: {
+            ...record.data,
+            ...updatedDeletedMetaFields,
+            wbyDeleted: storageEntry.wbyDeleted,
+            location: storageEntry.location,
+            binOriginalFolderId: storageEntry.binOriginalFolderId
+          }
+        };
+      })
     });
     /**
      * And finally write it...
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not move the entry to the bin.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
+      throw new WebinyError(ex.message || "Could not move the entry to the bin.", ex.code || "MOVE_ENTRY_TO_BIN_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -457,44 +437,41 @@ const createEntriesStorageOperations = params => {
     } = params;
     const id = entry.id || entry.entryId;
     const model = getStorageOperationsModel(initialModel);
-    const queryAllParams = {
-      entity,
-      partitionKey: (0, _keys.createPartitionKey)({
-        id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      options: {
-        gte: " "
-      }
-    };
+    const partitionKey = createPartitionKey({
+      id,
+      tenant: model.tenant
+    });
     let records = [];
     try {
-      records = await (0, _query.queryAll)(queryAllParams);
+      records = await entity.queryAll({
+        partitionKey,
+        options: {
+          gte: " "
+        }
+      });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
+      throw new WebinyError(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
         error: ex,
         id
       });
     }
-    const items = records.map(item => {
-      return entity.deleteBatch({
-        PK: item.PK,
-        SK: item.SK
-      });
+    const entityBatch = entity.createEntityWriter({
+      delete: records.map(item => {
+        return {
+          PK: item.PK,
+          SK: item.SK
+        };
+      })
     });
     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 delete the entry.", ex.code || "DELETE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not delete the entry.", ex.code || "DELETE_ENTRY_ERROR", {
         error: ex,
-        partitionKey: queryAllParams.partitionKey,
+        partitionKey,
         id
       });
     }
@@ -509,26 +486,26 @@ const createEntriesStorageOperations = params => {
     /**
      * First we need to load all the revisions and published / latest entries.
      */
-    const queryAllParams = {
-      entity,
-      partitionKey: (0, _keys.createPartitionKey)({
-        id: entry.id,
-        locale: model.locale,
-        tenant: model.tenant
-      }),
-      options: {
-        gte: " "
-      }
-    };
     let records = [];
     try {
-      records = await (0, _query.queryAll)(queryAllParams);
+      records = await entity.queryAll({
+        partitionKey: createPartitionKey({
+          id: entry.id,
+          tenant: model.tenant
+        }),
+        options: {
+          gte: " "
+        }
+      });
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
+      throw new WebinyError(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
         error: ex,
         id: entry.id
       });
     }
+    if (records.length === 0) {
+      return initialStorageEntry;
+    }
     const storageEntry = convertToStorageEntry({
       model,
       storageEntry: initialStorageEntry
@@ -537,30 +514,33 @@ const createEntriesStorageOperations = params => {
     /**
      * Let's pick the `restored` meta fields from the storage entry.
      */
-    const updatedRestoredMetaFields = (0, _constants.pickEntryMetaFields)(storageEntry, _constants.isRestoredEntryMetaField);
-    const items = records.map(record => {
-      return entity.putBatch({
-        ...record,
-        ...updatedRestoredMetaFields,
-        wbyDeleted: storageEntry.wbyDeleted,
-        location: storageEntry.location,
-        binOriginalFolderId: storageEntry.binOriginalFolderId
-      });
+    const updatedRestoredMetaFields = pickEntryMetaFields(storageEntry, isRestoredEntryMetaField);
+    const entityBatch = entity.createEntityWriter({
+      put: records.map(record => {
+        return {
+          ...record,
+          data: {
+            ...record.data,
+            ...updatedRestoredMetaFields,
+            wbyDeleted: storageEntry.wbyDeleted,
+            location: storageEntry.location,
+            binOriginalFolderId: storageEntry.binOriginalFolderId
+          }
+        };
+      })
     });
+
     /**
      * And finally write it...
      */
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
       return initialStorageEntry;
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not restore the entry from the bin.", ex.code || "RESTORE_ENTRY_ERROR", {
+      throw new WebinyError(ex.message || "Could not restore the entry from the bin.", ex.code || "RESTORE_ENTRY_ERROR", {
         error: ex,
         entry,
         storageEntry
@@ -574,61 +554,55 @@ 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 items = [entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry)
-    })];
+    const entityBatch = entity.createEntityWriter({
+      delete: [{
+        PK: partitionKey,
+        SK: createRevisionSortKey(entry)
+      }]
+    });
     const publishedStorageEntry = await getPublishedRevisionByEntryId(model, entry);
 
     /**
      * If revision we are deleting is the published one as well, we need to delete those records as well.
      */
     if (publishedStorageEntry && entry.id === publishedStorageEntry.id) {
-      items.push(entity.deleteBatch({
+      entityBatch.delete({
         PK: partitionKey,
-        SK: (0, _keys.createPublishedSortKey)()
-      }));
+        SK: createPublishedSortKey()
+      });
     }
     if (initialLatestStorageEntry) {
       const latestStorageEntry = convertToStorageEntry({
         storageEntry: initialLatestStorageEntry,
         model
       });
-      items.push(entity.putBatch({
-        ...latestStorageEntry,
-        PK: partitionKey,
-        SK: (0, _keys.createLatestSortKey)(),
-        TYPE: createLatestType(),
-        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-        GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-      }));
+      entityBatch.put({
+        ...createEntryLatestKeys(latestStorageEntry),
+        data: {
+          ...latestStorageEntry
+        }
+      });
 
       // Do an update on the latest revision. We need to update the latest revision's
       // entry-level meta fields to match the previous revision's entry-level meta fields.
-      items.push(entity.putBatch({
-        ...initialLatestStorageEntry,
-        PK: partitionKey,
-        SK: (0, _keys.createRevisionSortKey)(initialLatestStorageEntry),
-        TYPE: createType(),
-        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-        GSI1_SK: (0, _keys.createGSISortKey)(initialLatestStorageEntry)
-      }));
+      entityBatch.put({
+        ...createEntryRevisionKeys(latestStorageEntry),
+        data: {
+          ...latestStorageEntry
+        }
+      });
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
     } catch (ex) {
-      throw new _error.default(ex.message, ex.code, {
+      throw new WebinyError(ex.message, ex.code, {
         error: ex,
         entry,
         latestEntry
@@ -650,50 +624,37 @@ const createEntriesStorageOperations = params => {
     /**
      * Then we need to construct the queries for all the revisions and entries.
      */
-    const items = [];
+
+    const entityBatch = entity.createEntityWriter();
     for (const id of entries) {
-      /**
-       * Latest item.
-       */
-      items.push(entity.deleteBatch({
-        PK: (0, _keys.createPartitionKey)({
-          id,
-          locale: model.locale,
-          tenant: model.tenant
-        }),
+      const partitionKey = createPartitionKey({
+        id,
+        tenant: model.tenant
+      });
+      entityBatch.delete({
+        PK: partitionKey,
         SK: "L"
-      }));
-      /**
-       * Published item.
-       */
-      items.push(entity.deleteBatch({
-        PK: (0, _keys.createPartitionKey)({
-          id,
-          locale: model.locale,
-          tenant: model.tenant
-        }),
+      });
+      entityBatch.delete({
+        PK: partitionKey,
         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 entityBatch.execute();
   };
   const getLatestRevisionByEntryId = async (initialModel, params) => {
     const model = getStorageOperationsModel(initialModel);
@@ -798,44 +759,34 @@ const createEntriesStorageOperations = params => {
       entryId,
       version
     } = params;
-    const queryParams = {
-      entity,
-      partitionKey: (0, _keys.createPartitionKey)({
-        tenant: model.tenant,
-        locale: model.locale,
-        id: entryId
-      }),
+    const partitionKey = createPartitionKey({
+      tenant: model.tenant,
+      id: entryId
+    });
+    const unfilteredRevisions = await entity.queryAll({
+      partitionKey,
       options: {
-        lt: `REV#${(0, _zeroPad.zeroPad)(version)}`,
-        /**
-         * We need to have extra checks because DynamoDB will return published or latest record if there is no REV# record.
-         */
-        filters: [{
-          attr: "TYPE",
-          eq: createType()
-        }, {
-          attr: "version",
-          lt: version
-        }],
+        beginsWith: `REV#`,
         reverse: true
       }
-    };
+    });
+    const filteredRevisions = unfilteredRevisions.filter(item => {
+      return item.data.version < version;
+    });
+    const storageEntry = filteredRevisions[0];
+    if (!storageEntry) {
+      return null;
+    }
     try {
-      const result = await (0, _query.queryOne)(queryParams);
-      const storageEntry = (0, _cleanup.cleanupItem)(entity, result);
-      if (!storageEntry) {
-        return null;
-      }
       return convertFromStorageEntry({
-        storageEntry,
+        storageEntry: storageEntry.data,
         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,
         model
       });
     }
@@ -852,22 +803,22 @@ const createEntriesStorageOperations = params => {
     } = params;
     const limit = initialLimit <= 0 || initialLimit >= MAX_LIST_LIMIT ? MAX_LIST_LIMIT : initialLimit;
     const type = initialWhere.published ? "P" : "L";
-    const queryAllParams = {
-      entity,
-      partitionKey: (0, _keys.createGSIPartitionKey)(model, type),
-      options: {
-        index: "GSI1",
-        gte: " "
-      }
+    const partitionKey = createGSIPartitionKey(model, type);
+    const options = {
+      index: "GSI1",
+      gte: " "
     };
     let storageEntries = [];
     try {
-      storageEntries = await (0, _query.queryAll)(queryAllParams);
+      storageEntries = await entity.queryAll({
+        partitionKey,
+        options
+      });
     } catch (ex) {
-      throw new _error.default(ex.message, "QUERY_ENTRIES_ERROR", {
+      throw new WebinyError(ex.message, "QUERY_ENTRIES_ERROR", {
         error: ex,
-        partitionKey: queryAllParams.partitionKey,
-        options: queryAllParams.options
+        partitionKey,
+        options
       });
     }
     if (storageEntries.length === 0) {
@@ -887,7 +838,7 @@ const createEntriesStorageOperations = params => {
      * We need an object containing field, transformers and paths.
      * Just build it here and pass on into other methods that require it to avoid mapping multiple times.
      */
-    const modelFields = (0, _createFields.createFields)({
+    const modelFields = createFields({
       plugins,
       fields: model.fields
     });
@@ -899,7 +850,7 @@ const createEntriesStorageOperations = params => {
      */
     const records = await Promise.all(storageEntries.map(async storageEntry => {
       const entry = convertFromStorageEntry({
-        storageEntry,
+        storageEntry: storageEntry.data,
         model
       });
       for (const field of model.fields) {
@@ -911,7 +862,7 @@ const createEntriesStorageOperations = params => {
      * Filter the read items via the code.
      * It will build the filters out of the where input and transform the values it is using.
      */
-    const filteredItems = (0, _filtering.filter)({
+    const filteredItems = filter({
       items: records,
       where,
       plugins,
@@ -927,14 +878,14 @@ const createEntriesStorageOperations = params => {
      * Sorting is also done via the code.
      * It takes the sort input and sorts by it via the lodash sortBy method.
      */
-    const sortedItems = (0, _filtering.sort)({
+    const sortedItems = sort({
       model,
       plugins,
       items: filteredItems,
       sort: sortBy,
       fields: modelFields
     });
-    const start = parseInt((0, _cursor.decodeCursor)(after) || "0") || 0;
+    const start = parseInt(decodeCursor(after) || "0") || 0;
     const hasMoreItems = totalCount > start + limit;
     const end = limit > totalCount + start + limit ? undefined : start + limit;
     const slicedItems = sortedItems.slice(start, end);
@@ -942,12 +893,12 @@ const createEntriesStorageOperations = params => {
      * Although we do not need a cursor here, we will use it as such to keep it standardized.
      * Number is simply encoded.
      */
-    const cursor = totalCount > start + limit ? (0, _cursor.encodeCursor)(`${start + limit}`) : null;
+    const cursor = encodeCursor(`${start + limit}`);
     return {
       hasMoreItems,
       totalCount,
       cursor,
-      items: (0, _cleanup.cleanupItems)(entity, slicedItems)
+      items: slicedItems
     };
   };
   const get = async (initialModel, params) => {
@@ -966,114 +917,125 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const partitionKey = (0, _keys.createPartitionKey)({
-      id: entry.id,
-      locale: model.locale,
-      tenant: model.tenant
-    });
 
     /**
      * We need the latest and published entries to see if something needs to be updated alongside the publishing one.
      */
     const initialLatestStorageEntry = await getLatestRevisionByEntryId(model, entry);
+    if (!initialLatestStorageEntry) {
+      throw new WebinyError(`Could not publish entry. Could not load latest ("L") record.`, "PUBLISH_ERROR", {
+        entry
+      });
+    }
     const initialPublishedStorageEntry = await getPublishedRevisionByEntryId(model, entry);
     const storageEntry = convertToStorageEntry({
       model,
       storageEntry: initialStorageEntry
     });
-    /**
-     * We need to update:
-     *  - current entry revision sort key
-     *  - published sort key
-     *  - the latest sort key - if entry updated is actually latest
-     *  - previous published entry to unpublished status - if any previously published entry
-     */
-    const items = [entity.putBatch({
-      ...storageEntry,
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      TYPE: createType(),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-      GSI1_SK: (0, _keys.createGSISortKey)(entry)
-    }), entity.putBatch({
-      ...storageEntry,
-      PK: partitionKey,
-      SK: (0, _keys.createPublishedSortKey)(),
-      TYPE: createPublishedType(),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
-      GSI1_SK: (0, _keys.createGSISortKey)(entry)
-    })];
-    if (initialLatestStorageEntry) {
-      const publishingLatestRevision = entry.id === initialLatestStorageEntry.id;
-      if (publishingLatestRevision) {
-        // We want to update current latest record because of the status (`status: 'published'`) update.
-        items.push(entity.putBatch({
-          ...storageEntry,
-          PK: partitionKey,
-          SK: (0, _keys.createLatestSortKey)(),
-          TYPE: createLatestType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-          GSI1_SK: (0, _keys.createGSISortKey)(entry)
-        }));
-      } else {
-        const latestStorageEntry = convertToStorageEntry({
-          storageEntry: initialLatestStorageEntry,
-          model
-        });
 
-        // If the published revision is not the latest one, we still need to
-        // update the latest record with the new values of entry-level meta fields.
-        const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
+    // 1. Update REV# and P records with new data.
+    const entityBatch = entity.createEntityWriter({
+      put: [{
+        ...createEntryRevisionKeys(storageEntry),
+        data: {
+          ...storageEntry
+        }
+      }, {
+        ...createEntryPublishedKeys(storageEntry),
+        data: {
+          ...storageEntry
+        }
+      }]
+    });
 
-        // 1. Update actual revision record.
-        items.push(entity.putBatch({
-          ...latestStorageEntry,
-          ...updatedEntryLevelMetaFields,
-          PK: partitionKey,
-          SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
-          TYPE: createType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-          GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
+    // 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 = initialPublishedStorageEntry?.id;
+    const publishingLatestRevision = entry.id === initialLatestStorageEntry.id;
+    if (publishingLatestRevision) {
+      // 2.1 If we're publishing the latest revision, we first need to update the L record.
+      entityBatch.put({
+        ...createEntryLatestKeys(storageEntry),
+        data: {
+          ...storageEntry
+        }
+      });
 
-        // 2. Update latest record.
-        items.push(entity.putBatch({
-          ...latestStorageEntry,
-          ...updatedEntryLevelMetaFields,
-          PK: partitionKey,
-          SK: (0, _keys.createLatestSortKey)(),
-          TYPE: createLatestType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-          GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
+      // 2.2 Additionally, if we have a previously published entry, we need to mark it as unpublished.
+      if (publishedRevisionId && publishedRevisionId !== entry.id) {
+        const publishedStorageEntry = convertToStorageEntry({
+          storageEntry: initialPublishedStorageEntry,
+          model
+        });
+        entityBatch.put({
+          ...createEntryRevisionKeys(publishedStorageEntry),
+          data: {
+            ...publishedStorageEntry,
+            status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+          }
+        });
       }
-    }
-    if (initialPublishedStorageEntry && initialPublishedStorageEntry.id !== entry.id) {
-      const publishedStorageEntry = convertToStorageEntry({
-        storageEntry: initialPublishedStorageEntry,
+    } 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);
+      const latestStorageEntry = convertToStorageEntry({
+        storageEntry: initialLatestStorageEntry,
         model
       });
-      items.push(entity.putBatch({
-        ...publishedStorageEntry,
-        PK: partitionKey,
-        SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry),
-        TYPE: createType(),
-        status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
-        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-        GSI1_SK: (0, _keys.createGSISortKey)(publishedStorageEntry)
-      }));
+
+      // 2.3.1 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
+      };
+      entityBatch.put({
+        ...createEntryLatestKeys(latestStorageEntryFields),
+        data: {
+          ...latestStorageEntryFields
+        }
+      });
+
+      // 2.3.2 Update REV# record.
+      entityBatch.put({
+        ...createEntryRevisionKeys(latestStorageEntryFields),
+        data: {
+          ...latestStorageEntryFields
+        }
+      });
+
+      // 2.3.3 Finally, if we got a published entry, but it wasn't the latest one, we need to take
+      //    an extra step and mark it as unpublished.
+      const publishedRevisionDifferentFromLatest = publishedRevisionId && publishedRevisionId !== latestStorageEntry.id;
+      if (publishedRevisionDifferentFromLatest) {
+        const publishedStorageEntry = convertToStorageEntry({
+          storageEntry: initialPublishedStorageEntry,
+          model
+        });
+        entityBatch.put({
+          ...createEntryRevisionKeys(publishedStorageEntry),
+          data: {
+            ...publishedStorageEntry,
+            status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+          }
+        });
+      }
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
       return initialStorageEntry;
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not execute the publishing batch.", ex.code || "PUBLISH_ERROR", {
+      throw new WebinyError(ex.message || "Could not execute the publishing batch.", ex.code || "PUBLISH_ERROR", {
         entry,
         latestStorageEntry: initialLatestStorageEntry,
         publishedStorageEntry: initialPublishedStorageEntry
@@ -1086,9 +1048,8 @@ const createEntriesStorageOperations = params => {
       storageEntry: initialStorageEntry
     } = params;
     const model = getStorageOperationsModel(initialModel);
-    const partitionKey = (0, _keys.createPartitionKey)({
+    const partitionKey = createPartitionKey({
       id: entry.id,
-      locale: model.locale,
       tenant: model.tenant
     });
     const storageEntry = convertToStorageEntry({
@@ -1101,17 +1062,18 @@ const createEntriesStorageOperations = params => {
      *  - update current entry revision with new data
      *  - update the latest entry status - if entry being unpublished is latest
      */
-    const items = [entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createPublishedSortKey)()
-    }), entity.putBatch({
-      ...storageEntry,
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry),
-      TYPE: createType(),
-      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-      GSI1_SK: (0, _keys.createGSISortKey)(entry)
-    })];
+    const entityBatch = entity.createEntityWriter({
+      delete: [{
+        PK: partitionKey,
+        SK: createPublishedSortKey()
+      }],
+      put: [{
+        ...createEntryRevisionKeys(storageEntry),
+        data: {
+          ...storageEntry
+        }
+      }]
+    });
 
     /**
      * We need the latest entry to see if something needs to be updated alongside the unpublishing one.
@@ -1120,14 +1082,12 @@ const createEntriesStorageOperations = params => {
     if (initialLatestStorageEntry) {
       const unpublishingLatestRevision = entry.id === initialLatestStorageEntry.id;
       if (unpublishingLatestRevision) {
-        items.push(entity.putBatch({
-          ...storageEntry,
-          PK: partitionKey,
-          SK: (0, _keys.createLatestSortKey)(),
-          TYPE: createLatestType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-          GSI1_SK: (0, _keys.createGSISortKey)(entry)
-        }));
+        entityBatch.put({
+          ...createEntryLatestKeys(storageEntry),
+          data: {
+            ...storageEntry
+          }
+        });
       } else {
         const latestStorageEntry = convertToStorageEntry({
           storageEntry: initialLatestStorageEntry,
@@ -1136,42 +1096,35 @@ const createEntriesStorageOperations = params => {
 
         // If the unpublished revision is not the latest one, we still need to
         // update the latest record with the new values of entry-level meta fields.
-        const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
+        const updatedEntryLevelMetaFields = pickEntryMetaFields(entry, isEntryLevelEntryMetaField);
 
         // 1. Update actual revision record.
-        items.push(entity.putBatch({
-          ...latestStorageEntry,
-          ...updatedEntryLevelMetaFields,
-          PK: partitionKey,
-          SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
-          TYPE: createType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
-          GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
+        entityBatch.put({
+          ...createEntryRevisionKeys(latestStorageEntry),
+          data: {
+            ...latestStorageEntry,
+            ...updatedEntryLevelMetaFields
+          }
+        });
 
         // 2. Update latest record.
-        items.push(entity.putBatch({
-          ...latestStorageEntry,
-          ...updatedEntryLevelMetaFields,
-          PK: partitionKey,
-          SK: (0, _keys.createLatestSortKey)(),
-          TYPE: createLatestType(),
-          GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
-          GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
+        entityBatch.put({
+          ...createEntryLatestKeys(latestStorageEntry),
+          data: {
+            ...latestStorageEntry,
+            ...updatedEntryLevelMetaFields
+          }
+        });
       }
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
       return initialStorageEntry;
     } catch (ex) {
-      throw new _error.default(ex.message || "Could not execute unpublish batch.", ex.code || "UNPUBLISH_ERROR", {
+      throw new WebinyError(ex.message || "Could not execute unpublish batch.", ex.code || "UNPUBLISH_ERROR", {
         entry,
         storageEntry
       });
@@ -1184,7 +1137,7 @@ const createEntriesStorageOperations = params => {
     } = 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
       });
     }
@@ -1239,6 +1192,5 @@ const createEntriesStorageOperations = params => {
     getUniqueFieldValues
   };
 };
-exports.createEntriesStorageOperations = createEntriesStorageOperations;
 
 //# sourceMappingURL=index.js.map