@webiny/api-page-builder-so-ddb-es 0.0.0-ee-vpcs.549378cf03

package/operations/pages/index.js

@@ -0,0 +1,829 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPageStorageOperations = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _omit = _interopRequireDefault(require("lodash/omit"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _configurations = require("../../configurations");
+
+var _apiElasticsearch = require("@webiny/api-elasticsearch");
+
+var _elasticsearchQueryBody = require("./elasticsearchQueryBody");
+
+var _SearchLatestPagesPlugin = require("../../plugins/definitions/SearchLatestPagesPlugin");
+
+var _SearchPublishedPagesPlugin = require("../../plugins/definitions/SearchPublishedPagesPlugin");
+
+var _query = require("@webiny/db-dynamodb/utils/query");
+
+var _batchWrite = require("@webiny/db-dynamodb/utils/batchWrite");
+
+var _helpers = require("./helpers");
+
+var _keys = require("./keys");
+
+var _sort = require("@webiny/db-dynamodb/utils/sort");
+
+var _PageDynamoDbElasticsearchFieldPlugin = require("../../plugins/definitions/PageDynamoDbElasticsearchFieldPlugin");
+
+/**
+ * This function removes attributes that were once present in the Page record, which we no longer need.
+ */
+function removePageAttributes(item) {
+  return (0, _omit.default)(item, ["home", "notFound", "visibility"]);
+}
+
+const createPageStorageOperations = params => {
+  const {
+    entity,
+    esEntity,
+    elasticsearch,
+    plugins
+  } = params;
+
+  const create = async params => {
+    const {
+      page
+    } = params;
+    const versionKeys = {
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createSortKey)(page)
+    };
+    const latestKeys = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, versionKeys), {}, {
+      SK: (0, _keys.createLatestSortKey)()
+    });
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), versionKeys), {}, {
+      TYPE: (0, _keys.createBasicType)()
+    })), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), latestKeys), {}, {
+      TYPE: (0, _keys.createLatestType)()
+    }))];
+    const esData = (0, _helpers.getESLatestPageData)(plugins, page);
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items: items
+      });
+      await esEntity.put((0, _objectSpread2.default)({
+        index: _configurations.configurations.es(page).index,
+        data: esData
+      }, latestKeys));
+      return page;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create new page.", ex.code || "CREATE_PAGE_ERROR", {
+        versionKeys,
+        latestKeys,
+        page
+      });
+    }
+  };
+
+  const createFrom = async params => {
+    const {
+      page,
+      latestPage,
+      original
+    } = params;
+    const versionKeys = {
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createSortKey)(page)
+    };
+    const latestKeys = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, versionKeys), {}, {
+      SK: (0, _keys.createLatestSortKey)()
+    });
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+      TYPE: (0, _keys.createBasicType)()
+    }, versionKeys)), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+      TYPE: (0, _keys.createLatestType)()
+    }, latestKeys))];
+    const esData = (0, _helpers.getESLatestPageData)(plugins, page);
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      await esEntity.put((0, _objectSpread2.default)({
+        index: _configurations.configurations.es(page).index,
+        data: esData
+      }, latestKeys));
+      return page;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create new page from existing page.", ex.code || "CREATE_PAGE_FROM_ERROR", {
+        versionKeys,
+        latestKeys,
+        latestPage,
+        original,
+        page
+      });
+    }
+  };
+
+  const update = async params => {
+    const {
+      original,
+      page
+    } = params;
+    const keys = {
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createSortKey)(page)
+    };
+    const latestKeys = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, keys), {}, {
+      SK: (0, _keys.createLatestSortKey)()
+    });
+    const latestPageResult = await entity.get(latestKeys);
+    const latestPage = (0, _cleanup.cleanupItem)(entity, latestPageResult ? latestPageResult.Item : null);
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+      TYPE: (0, _keys.createBasicType)()
+    }, keys))];
+    const esData = (0, _helpers.getESLatestPageData)(plugins, page);
+
+    if (latestPage && latestPage.id === page.id) {
+      /**
+       * We also update the regular record.
+       */
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+        TYPE: (0, _keys.createLatestType)()
+      }, latestKeys)));
+    }
+    /**
+     * Unfortunately we cannot push regular and es record in the batch write because they are two separate tables.
+     */
+
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+      await esEntity.put((0, _objectSpread2.default)({
+        index: _configurations.configurations.es(page).index,
+        data: esData
+      }, latestKeys));
+      return page;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update existing page.", ex.code || "UPDATE_PAGE_ERROR", {
+        original,
+        page,
+        latestPage,
+        latestKeys,
+        keys
+      });
+    }
+  };
+  /**
+   * In case of delete, we must delete records:
+   *  - revision
+   *  - path if published
+   * Update:
+   *  - latest
+   */
+
+
+  const deleteOne = async params => {
+    const {
+      page,
+      latestPage,
+      publishedPage
+    } = params;
+    const partitionKey = (0, _keys.createPartitionKey)(page);
+    const items = [entity.deleteBatch({
+      PK: partitionKey,
+      SK: (0, _keys.createSortKey)(page)
+    })];
+    const esItems = [];
+
+    if (publishedPage && publishedPage.id === page.id) {
+      items.push(entity.deleteBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }));
+      items.push(entity.deleteBatch({
+        PK: (0, _keys.createPathPartitionKey)(page),
+        SK: (0, _keys.createPathSortKey)(page)
+      }));
+      esItems.push(esEntity.deleteBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }));
+    }
+
+    let previousLatestPage = null;
+
+    if (latestPage && latestPage.id === page.id) {
+      const previousLatestRecord = await (0, _query.queryOne)({
+        entity,
+        partitionKey,
+        options: {
+          lt: (0, _keys.createSortKey)(latestPage),
+          reverse: true
+        }
+      });
+
+      if (previousLatestRecord) {
+        items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, previousLatestRecord), {}, {
+          TYPE: (0, _keys.createLatestType)(),
+          PK: partitionKey,
+          SK: (0, _keys.createLatestSortKey)()
+        })));
+        esItems.push(esEntity.putBatch({
+          PK: partitionKey,
+          SK: (0, _keys.createLatestSortKey)(),
+          index: _configurations.configurations.es(page).index,
+          data: (0, _helpers.getESLatestPageData)(plugins, previousLatestRecord)
+        }));
+        previousLatestPage = (0, _cleanup.cleanupItem)(entity, previousLatestRecord);
+      }
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not batch write all the page records.", ex.code || "BATCH_WRITE_RECORDS_ERROR");
+    }
+
+    if (esItems.length === 0) {
+      return [page, previousLatestPage];
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items: esItems
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not batch write all the page Elasticsearch records.", ex.code || "BATCH_WRITE_ELASTICSEARCH_RECORDS_ERROR");
+    }
+
+    return [page, previousLatestPage];
+  };
+  /**
+   * In case of deleteAll, we must delete records:
+   *  - latest
+   *  - published
+   *  - path if published
+   *  - revision
+   *  - es latest
+   *  - es published
+   */
+
+
+  const deleteAll = async params => {
+    const {
+      page
+    } = params;
+    const partitionKey = (0, _keys.createPartitionKey)(page);
+    const queryAllParams = {
+      entity,
+      partitionKey,
+      options: {
+        gte: " "
+      }
+    };
+    let revisions;
+
+    try {
+      revisions = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not query for all revisions of the page.", ex.code || "LIST_REVISIONS_ERROR", {
+        params: queryAllParams
+      });
+    }
+    /**
+     * We need to go through all possible entries and delete them.
+     * Also, delete the published entry path record.
+     */
+
+
+    const items = [];
+    let publishedPathEntryDeleted = false;
+
+    for (const revision of revisions) {
+      if (revision.status === "published" && !publishedPathEntryDeleted) {
+        publishedPathEntryDeleted = true;
+        items.push(entity.deleteBatch({
+          PK: (0, _keys.createPathPartitionKey)(page),
+          SK: revision.path
+        }));
+      }
+
+      items.push(entity.deleteBatch({
+        PK: revision.PK,
+        SK: revision.SK
+      }));
+    }
+
+    const esItems = [esEntity.deleteBatch({
+      PK: partitionKey,
+      SK: (0, _keys.createLatestSortKey)()
+    })];
+    /**
+     * Delete published record if it is published.
+     */
+
+    if (publishedPathEntryDeleted) {
+      esItems.push(esEntity.deleteBatch({
+        PK: partitionKey,
+        SK: (0, _keys.createPublishedSortKey)()
+      }));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete all the page records.", ex.code || "DELETE_RECORDS_ERROR");
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items: esItems
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete all the page Elasticsearch records.", ex.code || "DELETE_ELASTICSEARCH_RECORDS_ERROR");
+    }
+
+    return [page];
+  };
+
+  const publish = async params => {
+    const {
+      page,
+      latestPage,
+      publishedPage
+    } = params;
+    /**
+     * Update the given revision of the page.
+     */
+
+    const items = [entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+      TYPE: (0, _keys.createBasicType)(),
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createSortKey)(page)
+    }))];
+    const esItems = [];
+    /**
+     * If we are publishing the latest revision, let's also update the latest revision entry's
+     * status in ES. Also, if we are publishing the latest revision, we need to update the latest
+     * page revision entry in ES.
+     */
+
+    if (latestPage.id === page.id) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+        TYPE: (0, _keys.createLatestType)(),
+        PK: (0, _keys.createPartitionKey)(page),
+        SK: (0, _keys.createLatestSortKey)()
+      })));
+      esItems.push(esEntity.putBatch({
+        PK: (0, _keys.createPartitionKey)(page),
+        SK: (0, _keys.createLatestSortKey)(),
+        index: _configurations.configurations.es(page).index,
+        data: (0, _helpers.getESLatestPageData)(plugins, page)
+      }));
+    }
+    /**
+     * If we have already published revision of this page:
+     *  - set existing published page revision to unpublished
+     *  - remove old published path if paths are different
+     */
+
+
+    if (publishedPage) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, publishedPage), {}, {
+        status: "unpublished",
+        PK: (0, _keys.createPartitionKey)(publishedPage),
+        SK: (0, _keys.createSortKey)(publishedPage)
+      })));
+      /**
+       * Remove old published path if required.
+       */
+
+      if (publishedPage.path !== page.path) {
+        items.push(entity.deleteBatch({
+          PK: (0, _keys.createPathPartitionKey)(page),
+          SK: publishedPage.path
+        }));
+      }
+    }
+
+    esItems.push(esEntity.putBatch({
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createPublishedSortKey)(),
+      index: _configurations.configurations.es(page).index,
+      data: (0, _helpers.getESPublishedPageData)(plugins, page)
+    }));
+    /**
+     * Update or insert published path.
+     */
+
+    items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+      TYPE: (0, _keys.createPublishedPathType)(),
+      PK: (0, _keys.createPathPartitionKey)(page),
+      SK: (0, _keys.createPathSortKey)(page)
+    })));
+    /**
+     * Update or insert published page.
+     */
+
+    items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+      TYPE: (0, _keys.createPublishedType)(),
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createPublishedSortKey)()
+    })));
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update all the page records when publishing.", ex.code || "UPDATE_RECORDS_ERROR");
+    }
+    /**
+     * No point in continuing if there are no items in Elasticsearch data
+     */
+
+
+    if (esItems.length === 0) {
+      return page;
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: esItems
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update all the page Elasticsearch records when publishing.", ex.code || "UPDATE_ELASTICSEARCH_RECORDS_ERROR");
+    }
+
+    return page;
+  };
+
+  const unpublish = async params => {
+    const {
+      page,
+      latestPage
+    } = params;
+    const items = [entity.deleteBatch({
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createPublishedSortKey)()
+    }), entity.deleteBatch({
+      PK: (0, _keys.createPathPartitionKey)(page),
+      SK: (0, _keys.createPathSortKey)(page)
+    }), entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+      TYPE: (0, _keys.createBasicType)(),
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createSortKey)(page)
+    }))];
+    const esItems = [];
+    /*
+     * If we are unpublishing the latest revision, let's also update the latest revision entry's status in ES.
+     */
+
+    if (latestPage.id === page.id) {
+      items.push(entity.putBatch((0, _objectSpread2.default)((0, _objectSpread2.default)({}, page), {}, {
+        TYPE: (0, _keys.createLatestType)(),
+        PK: (0, _keys.createPartitionKey)(page),
+        SK: (0, _keys.createLatestSortKey)()
+      })));
+      esItems.push(esEntity.putBatch({
+        PK: (0, _keys.createPartitionKey)(page),
+        SK: (0, _keys.createLatestSortKey)(),
+        index: _configurations.configurations.es(page).index,
+        data: (0, _helpers.getESLatestPageData)(plugins, page)
+      }));
+    }
+
+    esItems.push(esEntity.deleteBatch({
+      PK: (0, _keys.createPartitionKey)(page),
+      SK: (0, _keys.createPublishedSortKey)()
+    }));
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: entity.table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update all the page records when unpublishing.", ex.code || "UPDATE_RECORDS_ERROR");
+    }
+    /**
+     * No need to go further if no Elasticsearch items to be applied.
+     */
+
+
+    if (esItems.length === 0) {
+      return page;
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: esEntity.table,
+        items: esItems
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update all the page Elasticsearch records when unpublishing.", ex.code || "UPDATE_ELASTICSEARCH_RECORDS_ERROR");
+    }
+
+    return page;
+  };
+
+  const get = async params => {
+    const {
+      where
+    } = params;
+    const {
+      pid,
+      id,
+      path,
+      published
+    } = where;
+    let {
+      version
+    } = where;
+    /**
+     * In case of having full ID and not having version we can take the version from the id.
+     */
+
+    if (id && id.includes("#") && !version) {
+      version = Number(id.split("#").pop());
+    }
+
+    let partitionKey = null;
+    let sortKey;
+
+    if (path) {
+      partitionKey = (0, _keys.createPathPartitionKey)(where);
+      sortKey = path;
+    } else if (published) {
+      sortKey = (0, _keys.createPublishedSortKey)();
+    } else if (version) {
+      sortKey = (0, _keys.createSortKey)({
+        version
+      });
+    } else {
+      sortKey = (0, _keys.createLatestSortKey)();
+    }
+    /**
+     * If partition key is still undefined, create one with id or pid
+     */
+
+
+    if (!partitionKey) {
+      partitionKey = (0, _keys.createPartitionKey)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, where), {}, {
+        id: pid || id
+      }));
+    }
+
+    const keys = {
+      PK: partitionKey,
+      SK: sortKey
+    };
+
+    try {
+      const result = await entity.get(keys);
+
+      if (!result || !result.Item) {
+        return null;
+      }
+
+      return (0, _cleanup.cleanupItem)(entity, result.Item);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not load page by given params.", ex.code || "GET_PAGE_ERROR", {
+        where,
+        keys
+      });
+    }
+  };
+
+  const list = async params => {
+    /**
+     * We do not allow loading both published and latest at the same time.
+     * @see PageStorageOperationsListWhere
+     */
+    if (params.where.published && params.where.latest) {
+      throw new _error.default("Both published and latest cannot be defined at the same time.", "MALFORMED_WHERE_ERROR", {
+        where: params.where
+      });
+    }
+
+    const {
+      after: previousCursor = null,
+      limit: initialLimit
+    } = params;
+    const limit = (0, _apiElasticsearch.createLimit)(initialLimit, 50);
+    const body = (0, _elasticsearchQueryBody.createElasticsearchQueryBody)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
+      where: (0, _objectSpread2.default)({}, params.where),
+      limit,
+      after: previousCursor,
+      plugins
+    }));
+    let searchPlugins = [];
+
+    if (params.where.published) {
+      searchPlugins = plugins.byType(_SearchPublishedPagesPlugin.SearchPublishedPagesPlugin.type);
+    } else if (params.where.latest) {
+      searchPlugins = plugins.byType(_SearchLatestPagesPlugin.SearchLatestPagesPlugin.type);
+    } else {
+      throw new _error.default("Only published or latest can be listed. Missing where condition.", "MALFORMED_WHERE_ERROR", {
+        where: params.where
+      });
+    }
+
+    for (const plugin of searchPlugins) {
+      /**
+       * Apply query modifications
+       */
+      plugin.modifyQuery({
+        query: body.query,
+        args: params,
+        plugins
+      });
+      /**
+       * Apply sort modifications
+       */
+
+      plugin.modifySort({
+        sort: body.sort,
+        args: params,
+        plugins
+      });
+    }
+
+    let response;
+
+    const esConfig = _configurations.configurations.es(params.where);
+
+    try {
+      response = await elasticsearch.search((0, _objectSpread2.default)((0, _objectSpread2.default)({}, esConfig), {}, {
+        body
+      }));
+    } catch (ex) {
+      /**
+       * Do not throw the error if Elasticsearch index does not exist.
+       * In some CRUDs we try to get list of pages but index was not created yet.
+       */
+      if (ex.message === "index_not_found_exception") {
+        return {
+          items: [],
+          meta: {
+            hasMoreItems: false,
+            totalCount: 0,
+            cursor: null
+          }
+        };
+      }
+
+      throw new _error.default(ex.message || "Could not load pages by given Elasticsearch body.", ex.code || "LIST_PAGES_ERROR", {
+        body
+      });
+    }
+
+    const {
+      hits,
+      total
+    } = response.body.hits;
+    const items = hits.map(item => item._source).map(item => removePageAttributes(item));
+    const hasMoreItems = items.length > limit;
+
+    if (hasMoreItems) {
+      /**
+       * Remove the last item from results, we don't want to include it.
+       */
+      items.pop();
+    }
+    /**
+     * Cursor is the `sort` value of the last item in the array.
+     * https://www.elastic.co/guide/en/elasticsearch/reference/current/paginate-search-results.html#search-after
+     */
+
+
+    const cursor = items.length > 0 && hasMoreItems ? (0, _apiElasticsearch.encodeCursor)(hits[items.length - 1].sort) || null : null;
+    return {
+      items,
+      meta: {
+        hasMoreItems,
+        totalCount: total.value,
+        cursor
+      }
+    };
+  };
+
+  const listTags = async params => {
+    const {
+      where
+    } = params;
+    const tenant = where.tenant;
+    const body = (0, _elasticsearchQueryBody.createElasticsearchQueryBody)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
+      where: {
+        locale: where.locale,
+        search: undefined,
+        tenant
+      },
+      sort: [],
+      after: null,
+      limit: 100000,
+      plugins
+    }));
+
+    const esConfig = _configurations.configurations.es(where);
+
+    try {
+      const response = await elasticsearch.search((0, _objectSpread2.default)((0, _objectSpread2.default)({}, esConfig), {}, {
+        body: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, body), {}, {
+          sort: undefined,
+          limit: undefined,
+          size: 0,
+          aggs: {
+            tags: {
+              terms: {
+                field: "tags.keyword",
+                include: `.*${where.search}.*`,
+                size: 10
+              }
+            }
+          }
+        })
+      }));
+      const tags = response.body.aggregations["tags"];
+
+      if (!tags || Array.isArray(tags.buckets) === false) {
+        return [];
+      }
+
+      return tags.buckets.map(item => item.key);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not list tags by given parameters.", ex.code || "LIST_TAGS_ERROR", {
+        body,
+        where
+      });
+    }
+  };
+
+  const listRevisions = async params => {
+    const {
+      where,
+      sort
+    } = params;
+    const queryAllParams = {
+      entity,
+      partitionKey: (0, _keys.createPartitionKey)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, where), {}, {
+        id: where.pid
+      })),
+      options: {
+        beginsWith: "REV#",
+        reverse: false
+      }
+    };
+    let items = [];
+
+    try {
+      items = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not load all the revisions from requested page.", ex.code || "LOAD_PAGE_REVISIONS_ERROR", {
+        params
+      });
+    }
+
+    const fields = plugins.byType(_PageDynamoDbElasticsearchFieldPlugin.PageDynamoDbElasticsearchFieldPlugin.type);
+    return (0, _sort.sortItems)({
+      items: items.map(item => removePageAttributes(item)),
+      fields,
+      sort
+    });
+  };
+
+  return {
+    create,
+    createFrom,
+    update,
+    delete: deleteOne,
+    deleteAll: deleteAll,
+    publish,
+    unpublish,
+    get,
+    list,
+    listRevisions,
+    listTags
+  };
+};
+
+exports.createPageStorageOperations = createPageStorageOperations;