@webiny/api-headless-cms-ddb 0.0.0-unstable.496cf268ac → 0.0.0-unstable.5387e5f7c8

package/operations/entry/index.js

@@ -1,787 +0,0 @@
-"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)({
-      model,
-      plugins,
-      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;