@webiny/api-headless-cms-ddb 5.41.4-beta.4 → 5.41.4-beta.6

package/operations/entry/index.js

@@ -9,9 +9,7 @@ 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 _dbDynamodb = require("@webiny/db-dynamodb");
 var _cursor = require("@webiny/utils/cursor");
 var _zeroPad = require("@webiny/utils/zeroPad");
 var _apiHeadlessCms = require("@webiny/api-headless-cms");
@@ -120,29 +118,32 @@ const createEntriesStorageOperations = params => {
      *  - 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 = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        locked,
+        PK: partitionKey,
+        SK: (0, _keys.createRevisionSortKey)(entry),
+        TYPE: createType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      }, {
+        ...storageEntry,
+        locked,
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: createLatestType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      }]
+    });
 
     /**
      * We need to create published entry if
      */
     if (isPublished) {
-      items.push(entity.putBatch({
+      entityBatch.put({
         ...storageEntry,
         locked,
         PK: partitionKey,
@@ -150,13 +151,10 @@ const createEntriesStorageOperations = params => {
         TYPE: createLatestType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
         GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-      }));
+      });
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
@@ -192,31 +190,34 @@ const createEntriesStorageOperations = params => {
      *      - 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)
-    })];
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        PK: partitionKey,
+        SK: (0, _keys.createRevisionSortKey)(storageEntry),
+        TYPE: createType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      }, {
+        ...storageEntry,
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: createLatestType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      }]
+    });
     const isPublished = entry.status === "published";
     if (isPublished) {
-      items.push(entity.putBatch({
+      entityBatch.put({
         ...storageEntry,
         PK: partitionKey,
         SK: (0, _keys.createPublishedSortKey)(),
         TYPE: createPublishedType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
         GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-      }));
+      });
 
       // Unpublish previously published revision (if any).
       const [publishedRevisionStorageEntry] = await dataLoaders.getPublishedRevisionByEntryId({
@@ -224,7 +225,7 @@ const createEntriesStorageOperations = params => {
         ids: [entry.id]
       });
       if (publishedRevisionStorageEntry) {
-        items.push(entity.putBatch({
+        entityBatch.put({
           ...publishedRevisionStorageEntry,
           PK: partitionKey,
           SK: (0, _keys.createRevisionSortKey)(publishedRevisionStorageEntry),
@@ -232,14 +233,11 @@ const createEntriesStorageOperations = params => {
           status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
           GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
           GSI1_SK: (0, _keys.createGSISortKey)(publishedRevisionStorageEntry)
-        }));
+        });
       }
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
@@ -268,7 +266,6 @@ const createEntriesStorageOperations = params => {
     });
     const isPublished = entry.status === "published";
     const locked = isPublished ? true : entry.locked;
-    const items = [];
     const storageEntry = convertToStorageEntry({
       model,
       storageEntry: initialStorageEntry
@@ -278,17 +275,21 @@ 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 = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        locked,
+        PK: partitionKey,
+        SK: (0, _keys.createRevisionSortKey)(storageEntry),
+        TYPE: createType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      }]
+    });
     if (isPublished) {
-      items.push(entity.putBatch({
+      entityBatch.put({
         ...storageEntry,
         locked,
         PK: partitionKey,
@@ -296,7 +297,7 @@ const createEntriesStorageOperations = params => {
         TYPE: createPublishedType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
         GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
-      }));
+      });
     }
 
     /**
@@ -306,7 +307,7 @@ const createEntriesStorageOperations = params => {
     if (latestStorageEntry) {
       const updatingLatestRevision = latestStorageEntry.id === entry.id;
       if (updatingLatestRevision) {
-        items.push(entity.putBatch({
+        entityBatch.put({
           ...storageEntry,
           locked,
           PK: partitionKey,
@@ -314,7 +315,7 @@ const createEntriesStorageOperations = params => {
           TYPE: createLatestType(),
           GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
           GSI1_SK: (0, _keys.createGSISortKey)(entry)
-        }));
+        });
       } else {
         /**
          * If not updating latest revision, we still want to update the latest revision's
@@ -327,7 +328,7 @@ const createEntriesStorageOperations = params => {
          * - one for the actual revision record
          * - one for the latest record
          */
-        items.push(entity.putBatch({
+        entityBatch.put({
           ...latestStorageEntry,
           ...updatedEntryLevelMetaFields,
           PK: partitionKey,
@@ -335,8 +336,8 @@ const createEntriesStorageOperations = params => {
           TYPE: createType(),
           GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
           GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
-        items.push(entity.putBatch({
+        });
+        entityBatch.put({
           ...latestStorageEntry,
           ...updatedEntryLevelMetaFields,
           PK: partitionKey,
@@ -344,14 +345,11 @@ const createEntriesStorageOperations = params => {
           TYPE: createLatestType(),
           GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
           GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
+        });
       }
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
@@ -385,27 +383,28 @@ const createEntriesStorageOperations = params => {
         gte: " "
       }
     };
-    const records = await (0, _query.queryAll)(queryAllParams);
+    const records = await (0, _dbDynamodb.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 = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: records.map(item => {
+        return {
+          ...item,
+          location: {
+            ...item.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, {
         message: "Could not move records to a new folder.",
@@ -439,13 +438,16 @@ const createEntriesStorageOperations = params => {
     };
     let records = [];
     try {
-      records = await (0, _query.queryAll)(queryAllParams);
+      records = await (0, _dbDynamodb.queryAll)(queryAllParams);
     } catch (ex) {
       throw new _error.default(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
@@ -459,23 +461,23 @@ const createEntriesStorageOperations = params => {
     /**
      * 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 = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: records.map(record => {
+        return {
+          ...record,
+          ...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", {
         error: ex,
@@ -503,24 +505,24 @@ const createEntriesStorageOperations = params => {
     };
     let records = [];
     try {
-      records = await (0, _query.queryAll)(queryAllParams);
+      records = await (0, _dbDynamodb.queryAll)(queryAllParams);
     } catch (ex) {
       throw new _error.default(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 = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      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
       });
@@ -555,13 +557,16 @@ const createEntriesStorageOperations = params => {
     };
     let records = [];
     try {
-      records = await (0, _query.queryAll)(queryAllParams);
+      records = await (0, _dbDynamodb.queryAll)(queryAllParams);
     } catch (ex) {
       throw new _error.default(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
@@ -571,23 +576,24 @@ 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 entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: records.map(record => {
+        return {
+          ...record,
+          ...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
       });
@@ -612,51 +618,51 @@ const createEntriesStorageOperations = params => {
       locale: model.locale,
       tenant: model.tenant
     });
-    const items = [entity.deleteBatch({
-      PK: partitionKey,
-      SK: (0, _keys.createRevisionSortKey)(entry)
-    })];
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      delete: [{
+        PK: partitionKey,
+        SK: (0, _keys.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)()
-      }));
+      });
     }
     if (initialLatestStorageEntry) {
       const latestStorageEntry = convertToStorageEntry({
         storageEntry: initialLatestStorageEntry,
         model
       });
-      items.push(entity.putBatch({
+      entityBatch.put({
         ...latestStorageEntry,
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
         TYPE: createLatestType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
         GSI1_SK: (0, _keys.createGSISortKey)(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({
+      entityBatch.put({
         ...latestStorageEntry,
         PK: partitionKey,
         SK: (0, _keys.createRevisionSortKey)(initialLatestStorageEntry),
         TYPE: createType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
         GSI1_SK: (0, _keys.createGSISortKey)(initialLatestStorageEntry)
-      }));
+      });
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
@@ -683,36 +689,30 @@ const createEntriesStorageOperations = params => {
     /**
      * Then we need to construct the queries for all the revisions and entries.
      */
-    const items = [];
+
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity
+    });
     for (const id of entries) {
-      /**
-       * Latest item.
-       */
-      items.push(entity.deleteBatch({
-        PK: (0, _keys.createPartitionKey)({
-          id,
-          locale: model.locale,
-          tenant: model.tenant
-        }),
+      const partitionKey = (0, _keys.createPartitionKey)({
+        id,
+        locale: model.locale,
+        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({
+      entityBatch.delete({
         PK: (0, _keys.createPartitionKey)({
           id: revision.id,
           locale: model.locale,
@@ -721,12 +721,9 @@ const createEntriesStorageOperations = params => {
         SK: (0, _keys.createRevisionSortKey)({
           version: revision.version
         })
-      }));
+      });
     }
-    await (0, _batchWrite.batchWriteAll)({
-      table: entity.table,
-      items
-    });
+    await entityBatch.execute();
   };
   const getLatestRevisionByEntryId = async (initialModel, params) => {
     const model = getStorageOperationsModel(initialModel);
@@ -854,8 +851,8 @@ const createEntriesStorageOperations = params => {
       }
     };
     try {
-      const result = await (0, _query.queryOne)(queryParams);
-      const storageEntry = (0, _cleanup.cleanupItem)(entity, result);
+      const result = await (0, _dbDynamodb.queryOne)(queryParams);
+      const storageEntry = (0, _dbDynamodb.cleanupItem)(entity, result);
       if (!storageEntry) {
         return null;
       }
@@ -895,7 +892,7 @@ const createEntriesStorageOperations = params => {
     };
     let storageEntries = [];
     try {
-      storageEntries = await (0, _query.queryAll)(queryAllParams);
+      storageEntries = await (0, _dbDynamodb.queryAll)(queryAllParams);
     } catch (ex) {
       throw new _error.default(ex.message, "QUERY_ENTRIES_ERROR", {
         error: ex,
@@ -980,7 +977,7 @@ const createEntriesStorageOperations = params => {
       hasMoreItems,
       totalCount,
       cursor,
-      items: (0, _cleanup.cleanupItems)(entity, slicedItems)
+      items: (0, _dbDynamodb.cleanupItems)(entity, slicedItems)
     };
   };
   const get = async (initialModel, params) => {
@@ -1021,21 +1018,24 @@ const createEntriesStorageOperations = params => {
     });
 
     // 1. Update REV# and P records with new data.
-    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)
-    })];
+    const entityBatch = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      put: [{
+        ...storageEntry,
+        PK: partitionKey,
+        SK: (0, _keys.createRevisionSortKey)(entry),
+        TYPE: createType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
+        GSI1_SK: (0, _keys.createGSISortKey)(entry)
+      }, {
+        ...storageEntry,
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)(),
+        TYPE: createPublishedType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
+        GSI1_SK: (0, _keys.createGSISortKey)(entry)
+      }]
+    });
 
     // 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.
@@ -1043,14 +1043,14 @@ const createEntriesStorageOperations = params => {
     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.
-      items.push(entity.putBatch({
+      entityBatch.put({
         ...storageEntry,
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
         TYPE: createLatestType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
         GSI1_SK: (0, _keys.createGSISortKey)(entry)
-      }));
+      });
 
       // 2.2 Additionally, if we have a previously published entry, we need to mark it as unpublished.
       if (publishedRevisionId && publishedRevisionId !== entry.id) {
@@ -1058,7 +1058,7 @@ const createEntriesStorageOperations = params => {
           storageEntry: initialPublishedStorageEntry,
           model
         });
-        items.push(entity.putBatch({
+        entityBatch.put({
           ...publishedStorageEntry,
           PK: partitionKey,
           SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry),
@@ -1066,7 +1066,7 @@ const createEntriesStorageOperations = params => {
           status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
           GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
           GSI1_SK: (0, _keys.createGSISortKey)(publishedStorageEntry)
-        }));
+        });
       }
     } else {
       // 2.3 If the published revision is not the latest one, the situation is a bit
@@ -1089,24 +1089,24 @@ const createEntriesStorageOperations = params => {
         ...updatedEntryLevelMetaFields,
         status: latestRevisionStatus
       };
-      items.push(entity.putBatch({
+      entityBatch.put({
         ...latestStorageEntryFields,
         PK: partitionKey,
         SK: (0, _keys.createLatestSortKey)(),
         TYPE: createLatestType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
         GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-      }));
+      });
 
       // 2.3.2 Update REV# record.
-      items.push(entity.putBatch({
+      entityBatch.put({
         ...latestStorageEntryFields,
         PK: partitionKey,
         SK: (0, _keys.createRevisionSortKey)(latestStorageEntry),
         TYPE: createType(),
         GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
         GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-      }));
+      });
 
       // 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.
@@ -1116,7 +1116,7 @@ const createEntriesStorageOperations = params => {
           storageEntry: initialPublishedStorageEntry,
           model
         });
-        items.push(entity.putBatch({
+        entityBatch.put({
           ...publishedStorageEntry,
           PK: partitionKey,
           SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry),
@@ -1124,14 +1124,11 @@ const createEntriesStorageOperations = params => {
           status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
           GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
           GSI1_SK: (0, _keys.createGSISortKey)(publishedStorageEntry)
-        }));
+        });
       }
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });
@@ -1165,17 +1162,21 @@ 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 = (0, _dbDynamodb.createEntityWriteBatch)({
+      entity,
+      delete: [{
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }],
+      put: [{
+        ...storageEntry,
+        PK: partitionKey,
+        SK: (0, _keys.createRevisionSortKey)(entry),
+        TYPE: createType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
+        GSI1_SK: (0, _keys.createGSISortKey)(entry)
+      }]
+    });
 
     /**
      * We need the latest entry to see if something needs to be updated alongside the unpublishing one.
@@ -1184,14 +1185,14 @@ const createEntriesStorageOperations = params => {
     if (initialLatestStorageEntry) {
       const unpublishingLatestRevision = entry.id === initialLatestStorageEntry.id;
       if (unpublishingLatestRevision) {
-        items.push(entity.putBatch({
+        entityBatch.put({
           ...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,
@@ -1203,7 +1204,7 @@ const createEntriesStorageOperations = params => {
         const updatedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entry, _constants.isEntryLevelEntryMetaField);
 
         // 1. Update actual revision record.
-        items.push(entity.putBatch({
+        entityBatch.put({
           ...latestStorageEntry,
           ...updatedEntryLevelMetaFields,
           PK: partitionKey,
@@ -1211,10 +1212,10 @@ const createEntriesStorageOperations = params => {
           TYPE: createType(),
           GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "A"),
           GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
+        });
 
         // 2. Update latest record.
-        items.push(entity.putBatch({
+        entityBatch.put({
           ...latestStorageEntry,
           ...updatedEntryLevelMetaFields,
           PK: partitionKey,
@@ -1222,14 +1223,11 @@ const createEntriesStorageOperations = params => {
           TYPE: createLatestType(),
           GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
           GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
-        }));
+        });
       }
     }
     try {
-      await (0, _batchWrite.batchWriteAll)({
-        table: entity.table,
-        items
-      });
+      await entityBatch.execute();
       dataLoaders.clearAll({
         model
       });