@webiny/api-headless-cms-ddb 0.0.0-ee-vpcs.549378cf03

package/operations/entry/index.js

@@ -0,0 +1,872 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEntriesStorageOperations = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+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");
+
+const createType = () => {
+  return "cms.entry";
+};
+
+const createLatestType = () => {
+  return `${createType()}.l`;
+};
+
+const createPublishedType = () => {
+  return `${createType()}.p`;
+};
+
+const convertToStorageEntry = params => {
+  const {
+    model,
+    storageEntry
+  } = params;
+  const values = model.convertValueKeyToStorage({
+    fields: model.fields,
+    values: storageEntry.values
+  });
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+    values
+  });
+};
+
+const convertFromStorageEntry = params => {
+  const {
+    model,
+    storageEntry
+  } = params;
+  const values = model.convertValueKeyFromStorage({
+    fields: model.fields,
+    values: storageEntry.values
+  });
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+    values
+  });
+};
+
+const createEntriesStorageOperations = params => {
+  const {
+    entity,
+    plugins
+  } = params;
+  const dataLoaders = new _dataLoaders.DataLoadersHandler({
+    entity
+  });
+  const storageTransformPlugins = plugins.byType(_apiHeadlessCms.StorageTransformPlugin.type).reduce((collection, plugin) => {
+    collection[plugin.fieldType] = plugin;
+    return collection;
+  }, {});
+
+  const createStorageTransformCallable = model => {
+    return (field, value) => {
+      const plugin = storageTransformPlugins[field.type];
+
+      if (!plugin) {
+        return value;
+      }
+
+      return plugin.fromStorage({
+        model,
+        field,
+        value,
+
+        getStoragePlugin(fieldType) {
+          return storageTransformPlugins[fieldType] || storageTransformPlugins["*"];
+        },
+
+        plugins
+      });
+    };
+  };
+
+  const create = async (model, params) => {
+    const {
+      entry,
+      storageEntry: initialStorageEntry
+    } = params;
+    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
+    });
+    /**
+     * We need to:
+     *  - create new main entry item
+     *  - create new or update latest entry item
+     */
+
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked,
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)(),
+        TYPE: createLatestType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      })));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not insert data into the DynamoDB.", ex.code || "CREATE_ENTRY_ERROR", {
+        error: ex,
+        entry
+      });
+    }
+
+    return initialStorageEntry;
+  };
+
+  const createRevisionFrom = async (model, params) => {
+    const {
+      entry,
+      storageEntry: initialStorageEntry
+    } = params;
+    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
+     */
+
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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
+      });
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create revision from given entry.", ex.code || "CREATE_REVISION_ERROR", {
+        error: ex,
+        entry,
+        storageEntry
+      });
+    }
+    /**
+     * There are no modifications on the entry created so just return the data.
+     */
+
+
+    return initialStorageEntry;
+  };
+
+  const update = async (model, params) => {
+    const {
+      entry,
+      storageEntry: initialStorageEntry
+    } = params;
+    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
+    });
+    /**
+     * We need to:
+     *  - update the current entry
+     *  - update the latest entry if the current entry is the latest one
+     */
+
+    items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked,
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)(),
+        TYPE: createPublishedType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
+        GSI1_SK: (0, _keys.createGSISortKey)(storageEntry)
+      })));
+    }
+    /**
+     * We need the latest entry to update it as well if neccessary.
+     */
+
+
+    const latestStorageEntry = await getLatestRevisionByEntryId(model, entry);
+
+    if (latestStorageEntry && latestStorageEntry.id === entry.id) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        locked,
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: createLatestType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
+        GSI1_SK: (0, _keys.createGSISortKey)(entry)
+      })));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      dataLoaders.clearAll({
+        model
+      });
+      return initialStorageEntry;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update entry.", ex.code || "UPDATE_ERROR", {
+        error: ex,
+        entry,
+        latestStorageEntry
+      });
+    }
+  };
+
+  const deleteEntry = async (model, params) => {
+    const {
+      entry
+    } = params;
+    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);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
+        error: ex,
+        entry
+      });
+    }
+
+    const items = records.map(item => {
+      return entity.deleteBatch({
+        PK: item.PK,
+        SK: item.SK
+      });
+    });
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete the entry.", ex.code || "DELETE_ENTRY_ERROR", {
+        error: ex,
+        partitionKey: queryAllParams.partitionKey,
+        entry
+      });
+    }
+  };
+
+  const deleteRevision = async (model, params) => {
+    const {
+      entry,
+      latestEntry,
+      latestStorageEntry: initialLatestStorageEntry
+    } = params;
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const items = [entity.deleteBatch({
+      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({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }));
+    }
+
+    if (initialLatestStorageEntry) {
+      const latestStorageEntry = convertToStorageEntry({
+        storageEntry: initialLatestStorageEntry,
+        model
+      });
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, latestStorageEntry), {}, {
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: createLatestType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
+        GSI1_SK: (0, _keys.createGSISortKey)(latestStorageEntry)
+      })));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      dataLoaders.clearAll({
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message, ex.code, {
+        error: ex,
+        entry,
+        latestEntry
+      });
+    }
+  };
+
+  const getLatestRevisionByEntryId = async (model, params) => {
+    const items = await dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: [params.id]
+    });
+    const item = items.shift() || null;
+
+    if (!item) {
+      return null;
+    }
+
+    return convertFromStorageEntry({
+      storageEntry: item,
+      model
+    });
+  };
+
+  const getPublishedRevisionByEntryId = async (model, params) => {
+    const items = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: [params.id]
+    });
+    const item = items.shift() || null;
+
+    if (!item) {
+      return null;
+    }
+
+    return convertFromStorageEntry({
+      storageEntry: item,
+      model
+    });
+  };
+
+  const getRevisionById = async (model, params) => {
+    const items = await dataLoaders.getRevisionById({
+      model,
+      ids: [params.id]
+    });
+    const item = items.shift() || null;
+
+    if (!item) {
+      return null;
+    }
+
+    return convertFromStorageEntry({
+      storageEntry: item,
+      model
+    });
+  };
+
+  const getRevisions = async (model, params) => {
+    const items = await dataLoaders.getAllEntryRevisions({
+      model,
+      ids: [params.id]
+    });
+    return items.map(item => {
+      return convertFromStorageEntry({
+        storageEntry: item,
+        model
+      });
+    });
+  };
+
+  const getByIds = async (model, params) => {
+    const items = await dataLoaders.getRevisionById({
+      model,
+      ids: params.ids
+    });
+    return items.map(item => {
+      return convertFromStorageEntry({
+        storageEntry: item,
+        model
+      });
+    });
+  };
+
+  const getLatestByIds = async (model, params) => {
+    const items = await dataLoaders.getLatestRevisionByEntryId({
+      model,
+      ids: params.ids
+    });
+    return items.map(item => {
+      return convertFromStorageEntry({
+        storageEntry: item,
+        model
+      });
+    });
+  };
+
+  const getPublishedByIds = async (model, params) => {
+    const items = await dataLoaders.getPublishedRevisionByEntryId({
+      model,
+      ids: params.ids
+    });
+    return items.map(item => {
+      return convertFromStorageEntry({
+        storageEntry: item,
+        model
+      });
+    });
+  };
+
+  const getPreviousRevision = async (model, params) => {
+    const {
+      entryId,
+      version
+    } = params;
+    const queryParams = {
+      entity,
+      partitionKey: (0, _keys.createPartitionKey)({
+        tenant: model.tenant,
+        locale: model.locale,
+        id: entryId
+      }),
+      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
+        }],
+        reverse: true
+      }
+    };
+
+    try {
+      const result = await (0, _query.queryOne)(queryParams);
+      const storageEntry = (0, _cleanup.cleanupItem)(entity, result);
+
+      if (!storageEntry) {
+        return null;
+      }
+
+      return convertFromStorageEntry({
+        storageEntry,
+        model
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not get previous version of given entry.", ex.code || "GET_PREVIOUS_VERSION_ERROR", (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
+        error: ex,
+        partitionKey: queryParams.partitionKey,
+        options: queryParams.options,
+        model
+      }));
+    }
+  };
+
+  const list = async (model, params) => {
+    const {
+      limit: initialLimit = 10,
+      where: initialWhere,
+      after,
+      sort: sortBy,
+      fields,
+      search
+    } = params;
+    const limit = initialLimit <= 0 || initialLimit >= 10000 ? 10000 : initialLimit;
+    const type = initialWhere.published ? "P" : "L";
+    const queryAllParams = {
+      entity,
+      partitionKey: (0, _keys.createGSIPartitionKey)(model, type),
+      options: {
+        index: "GSI1",
+        gte: " "
+      }
+    };
+    let storageEntries = [];
+
+    try {
+      storageEntries = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message, "QUERY_ENTRIES_ERROR", {
+        error: ex,
+        partitionKey: queryAllParams.partitionKey,
+        options: queryAllParams.options
+      });
+    }
+
+    if (storageEntries.length === 0) {
+      return {
+        hasMoreItems: false,
+        totalCount: 0,
+        cursor: null,
+        items: []
+      };
+    }
+
+    const where = (0, _objectSpread2.default)({}, initialWhere);
+    delete where["published"];
+    delete where["latest"];
+    /**
+     * 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)({
+      plugins,
+      fields: model.fields
+    });
+    const fromStorage = createStorageTransformCallable(model);
+    /**
+     * Let's transform records from storage ones to regular ones, so we do not need to do it later.
+     *
+     * This is always being done, but at least its in parallel.
+     */
+
+    const records = await Promise.all(storageEntries.map(async storageEntry => {
+      const entry = convertFromStorageEntry({
+        storageEntry,
+        model
+      });
+
+      for (const field of model.fields) {
+        entry.values[field.fieldId] = await fromStorage(field, entry.values[field.fieldId]);
+      }
+
+      return entry;
+    }));
+    /**
+     * 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)({
+      items: records,
+      where,
+      plugins,
+      fields: modelFields,
+      fullTextSearch: {
+        term: search,
+        fields: fields || []
+      }
+    });
+    const totalCount = filteredItems.length;
+    /**
+     * 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)({
+      items: filteredItems,
+      sort: sortBy,
+      fields: modelFields
+    });
+    const start = parseInt((0, _cursor.decodeCursor)(after) || "0") || 0;
+    const hasMoreItems = totalCount > start + limit;
+    const end = limit > totalCount + start + limit ? undefined : start + limit;
+    const slicedItems = sortedItems.slice(start, end);
+    /**
+     * 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;
+    return {
+      hasMoreItems,
+      totalCount,
+      cursor,
+      items: (0, _cleanup.cleanupItems)(entity, slicedItems)
+    };
+  };
+
+  const get = async (model, params) => {
+    const {
+      items
+    } = await list(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
+      limit: 1
+    }));
+    return items.shift() || null;
+  };
+
+  const publish = async (model, params) => {
+    const {
+      entry,
+      storageEntry: initialStorageEntry
+    } = params;
+    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 along side the publishing one.
+     */
+
+    const initialLatestStorageEntry = await getLatestRevisionByEntryId(model, 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
+     *  - latest sort key - if entry updated is actually latest
+     *  - previous published entry to unpublished status - if any previously published entry
+     */
+
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: (0, _keys.createPublishedSortKey)(),
+      TYPE: createPublishedType(),
+      GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "P"),
+      GSI1_SK: (0, _keys.createGSISortKey)(entry)
+    }))];
+
+    if (initialLatestStorageEntry && entry.id === initialLatestStorageEntry.id) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: createLatestType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
+        GSI1_SK: (0, _keys.createGSISortKey)(entry)
+      })));
+    }
+
+    if (initialPublishedStorageEntry && initialPublishedStorageEntry.id !== entry.id) {
+      const publishedStorageEntry = convertToStorageEntry({
+        storageEntry: initialPublishedStorageEntry,
+        model
+      });
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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)
+      })));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      dataLoaders.clearAll({
+        model
+      });
+      return initialStorageEntry;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not execute the publishing batch.", ex.code || "PUBLISH_ERROR", {
+        entry,
+        latestStorageEntry: initialLatestStorageEntry,
+        publishedStorageEntry: initialPublishedStorageEntry
+      });
+    }
+  };
+
+  const unpublish = async (model, params) => {
+    const {
+      entry,
+      storageEntry: initialStorageEntry
+    } = params;
+    const partitionKey = (0, _keys.createPartitionKey)({
+      id: entry.id,
+      locale: model.locale,
+      tenant: model.tenant
+    });
+    const storageEntry = convertToStorageEntry({
+      storageEntry: initialStorageEntry,
+      model
+    });
+    /**
+     * We need to:
+     *  - delete currently published entry
+     *  - update current entry revision with new data
+     *  - update latest entry status - if entry being unpublished is latest
+     */
+
+    const items = [entity.deleteBatch({
+      PK: partitionKey,
+      SK: (0, _keys.createPublishedSortKey)()
+    }), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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 along side the unpublishing one.
+     */
+
+    const latestStorageEntry = await getLatestRevisionByEntryId(model, entry);
+
+    if (latestStorageEntry && entry.id === latestStorageEntry.id) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, storageEntry), {}, {
+        PK: partitionKey,
+        SK: (0, _keys.createLatestSortKey)(),
+        TYPE: createLatestType(),
+        GSI1_PK: (0, _keys.createGSIPartitionKey)(model, "L"),
+        GSI1_SK: (0, _keys.createGSISortKey)(entry)
+      })));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      dataLoaders.clearAll({
+        model
+      });
+      return initialStorageEntry;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not execute unpublish batch.", ex.code || "UNPUBLISH_ERROR", {
+        entry,
+        storageEntry
+      });
+    }
+  };
+
+  return {
+    create,
+    createRevisionFrom,
+    update,
+    delete: deleteEntry,
+    deleteRevision,
+    getPreviousRevision,
+    getPublishedByIds,
+    getLatestByIds,
+    getByIds,
+    getRevisionById,
+    getPublishedRevisionByEntryId,
+    getLatestRevisionByEntryId,
+    get,
+    getRevisions,
+    publish,
+    list,
+    unpublish
+  };
+};
+
+exports.createEntriesStorageOperations = createEntriesStorageOperations;