@webiny/api-headless-cms-ddb 5.17.4 → 5.18.0-beta.3

package/operations/entry/CmsContentEntryDynamo.js

@@ -1,972 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TYPE_ENTRY_PUBLISHED = exports.TYPE_ENTRY_LATEST = exports.TYPE_ENTRY = exports.CmsContentEntryDynamo = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _dataLoaders = require("./dataLoaders");
-
-var _types = require("@webiny/api-headless-cms/types");
-
-var _utils = require("@webiny/api-headless-cms/utils");
-
-var _utils2 = require("../../utils");
-
-var _utils3 = require("./utils");
-
-var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
-
-var _entry = require("../../definitions/entry");
-
-var _table = require("../../definitions/table");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-const TYPE_ENTRY = "cms.entry";
-exports.TYPE_ENTRY = TYPE_ENTRY;
-const TYPE_ENTRY_LATEST = TYPE_ENTRY + ".l";
-exports.TYPE_ENTRY_LATEST = TYPE_ENTRY_LATEST;
-const TYPE_ENTRY_PUBLISHED = TYPE_ENTRY + ".p";
-exports.TYPE_ENTRY_PUBLISHED = TYPE_ENTRY_PUBLISHED;
-const GSI1_INDEX = "GSI1";
-const configurationDefaults = {
-  defaultLimit: 100,
-  maxLimit: undefined
-};
-/**
- * We do not use transactions in this storage operations implementation due to their cost.
- */
-
-class CmsContentEntryDynamo {
-  get context() {
-    return this._context;
-  }
-
-  get configuration() {
-    return this._configuration;
-  }
-
-  get table() {
-    return this._table;
-  }
-
-  get entity() {
-    return this._entity;
-  }
-
-  constructor({
-    context,
-    configuration
-  }) {
-    (0, _defineProperty2.default)(this, "_context", void 0);
-    (0, _defineProperty2.default)(this, "_configuration", void 0);
-    (0, _defineProperty2.default)(this, "_modelPartitionKey", void 0);
-    (0, _defineProperty2.default)(this, "_dataLoaders", void 0);
-    (0, _defineProperty2.default)(this, "_table", void 0);
-    (0, _defineProperty2.default)(this, "_entity", void 0);
-    this._context = context;
-    this._configuration = _objectSpread(_objectSpread({}, configurationDefaults), configuration || {});
-    this._modelPartitionKey = `${this.partitionKey}#M`;
-    this._dataLoaders = new _dataLoaders.DataLoadersHandler(context, this);
-    this._table = (0, _table.createTable)({
-      context,
-      indexes: {
-        [GSI1_INDEX]: {
-          partitionKey: "GSI1_PK",
-          sortKey: "GSI1_SK"
-        }
-      }
-    });
-    this._entity = (0, _entry.createEntryEntity)({
-      table: this._table
-    });
-  }
-
-  async create(model, args) {
-    const {
-      entry,
-      storageEntry
-    } = args;
-    const partitionKey = this.getPartitionKey(entry.id);
-    /**
-     * We need to:
-     *  - create new main entry item
-     *  - create new or update latest entry item
-     */
-
-    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyRevision(entry.version),
-      TYPE: TYPE_ENTRY,
-      GSI1_PK: this.getGSIEntryPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(storageEntry)
-    })), this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyLatest(),
-      TYPE: TYPE_ENTRY_LATEST,
-      GSI1_PK: this.getGSILatestPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(storageEntry)
-    }))];
-
-    try {
-      await this._table.batchWrite(items);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not insert data into the DynamoDB.", ex.code || "CREATE_ENTRY_ERROR", {
-        error: ex,
-        entry
-      });
-    }
-
-    return storageEntry;
-  }
-
-  async createRevisionFrom(model, args) {
-    const {
-      originalEntry,
-      entry,
-      storageEntry,
-      latestEntry
-    } = args;
-    const partitionKey = this.getPartitionKey(storageEntry.id);
-    /**
-     * We need to:
-     *  - create the main entry item
-     *  - update the last entry item to a current one
-     */
-
-    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyRevision(storageEntry.version),
-      TYPE: TYPE_ENTRY,
-      GSI1_PK: this.getGSIEntryPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(storageEntry)
-    })), this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyLatest(),
-      TYPE: TYPE_ENTRY_LATEST,
-      GSI1_PK: this.getGSILatestPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(storageEntry)
-    }))];
-
-    try {
-      await this._table.batchWrite(items);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not create revision from given entry.", ex.code || "CREATE_REVISION_ERROR", {
-        error: ex,
-        originalEntry,
-        latestEntry,
-        entry,
-        storageEntry
-      });
-    }
-    /**
-     * There are no modifications on the entry created so just return the data.
-     */
-
-
-    return storageEntry;
-  }
-
-  async delete(model, args) {
-    const {
-      entry
-    } = args;
-    const partitionKey = this.getPartitionKey(entry.id);
-    const results = await this._entity.query(partitionKey, {
-      gte: " "
-    });
-    const keys = results.Items.map(item => ({
-      PK: partitionKey,
-      SK: item.SK
-    }));
-
-    try {
-      await this._table.batchWrite(keys.map(key => this._entity.deleteBatch(key)));
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not delete the entry.", ex.code || "DELETE_ENTRY_ERROR", {
-        error: ex,
-        partitionKey,
-        keys
-      });
-    }
-  }
-
-  async deleteRevision(model, args) {
-    const {
-      entryToDelete,
-      entryToSetAsLatest,
-      storageEntryToSetAsLatest
-    } = args;
-    const partitionKey = this.getPartitionKey(entryToDelete.id);
-    const items = [this._entity.deleteBatch({
-      PK: partitionKey,
-      SK: this.getSortKeyRevision(entryToDelete.id)
-    })];
-    const publishedStorageEntry = await this.getPublishedRevisionByEntryId(model, entryToDelete.id);
-    /**
-     * If revision we are deleting is the published one as well, we need to delete those records as well.
-     */
-
-    if (publishedStorageEntry && entryToDelete.id === publishedStorageEntry.id) {
-      items.push(this._entity.deleteBatch({
-        PK: partitionKey,
-        SK: this.getSortKeyPublished()
-      }));
-    }
-
-    if (storageEntryToSetAsLatest) {
-      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntryToSetAsLatest), {}, {
-        PK: partitionKey,
-        SK: this.getSortKeyLatest(),
-        TYPE: TYPE_ENTRY_LATEST,
-        GSI1_PK: this.getGSILatestPartitionKey(model),
-        GSI1_SK: this.getGSISortKey(storageEntryToSetAsLatest)
-      })));
-    }
-
-    try {
-      await this._table.batchWrite(items);
-    } catch (ex) {
-      throw new _error.default(ex.message, ex.code, {
-        error: ex,
-        entryToDelete,
-        entryToSetAsLatest
-      });
-    }
-  }
-
-  async get(model, args) {
-    const {
-      items
-    } = await this.list(model, _objectSpread(_objectSpread({}, args || {}), {}, {
-      limit: 1
-    }));
-
-    if (items.length === 0) {
-      return null;
-    }
-
-    return items.shift();
-  }
-
-  async list(model, args) {
-    const {
-      limit: initialLimit,
-      where: originalWhere,
-      after,
-      sort
-    } = args;
-    /**
-     * There is no max limit imposed because that is up to the devs using this.
-     * Default is some reasonable number for us but users can set their own when initializing the plugin.
-     */
-
-    const defaultLimit = this.configuration.defaultLimit || configurationDefaults.defaultLimit;
-    const maxLimit = this.configuration.maxLimit || defaultLimit;
-    const limit = !initialLimit || initialLimit <= 0 ? initialLimit > maxLimit ? maxLimit : defaultLimit : initialLimit;
-    const items = [];
-    const queryOptions = this.createQueryOptions({
-      where: originalWhere,
-      model
-    });
-
-    try {
-      /**
-       * We run the query method on all the partition keys that were built in the createQueryOptions() method.
-       * Partition keys are always built as array because of the possibility that we might need to read from different partitions
-       * which is the case if where condition is something like id_in or entryId_in.
-       * If we are reading from the GSI1_PK it is a single partition but we keep it as an array
-       * just to make it easier to read in all of the cases.
-       */
-      for (const partitionKey of queryOptions.queryPartitionKeys) {
-        const results = await this.runQuery({
-          partitionKey,
-          options: queryOptions.options
-        });
-        items.push(...results);
-      }
-    } catch (ex) {
-      throw new _error.default(ex.message, "SCAN_ERROR", {
-        error: ex
-      });
-    }
-    /**
-     * We need a 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, _utils3.buildModelFields)({
-      plugins: this.context.plugins,
-      model
-    });
-    /**
-     * 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, _utils3.filterItems)({
-      items,
-      where: queryOptions.where,
-      plugins: this.context.plugins,
-      fields: modelFields
-    });
-    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, _utils3.sortEntryItems)({
-      items: filteredItems,
-      sort,
-      fields: modelFields
-    });
-    const start = (0, _utils2.decodePaginationCursor)(after) || 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, _utils2.encodePaginationCursor)(start + limit) : null;
-    return {
-      hasMoreItems,
-      totalCount,
-      cursor,
-      items: slicedItems
-    };
-  }
-
-  async update(model, args) {
-    const {
-      originalEntry,
-      entry,
-      storageEntry
-    } = args;
-    const partitionKey = this.getPartitionKey(originalEntry.id);
-    const items = [];
-    /**
-     * We need to:
-     *  - update the current entry
-     *  - update the latest entry if the current entry is the latest one
-     */
-
-    items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyRevision(storageEntry.version),
-      TYPE: TYPE_ENTRY,
-      GSI1_PK: this.getGSIEntryPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(storageEntry)
-    })));
-    /**
-     * We need the latest entry to update it as well if neccessary.
-     */
-
-    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
-
-    if (latestStorageEntry && latestStorageEntry.id === entry.id) {
-      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: this.getSortKeyLatest(),
-        TYPE: TYPE_ENTRY_LATEST,
-        GSI1_PK: this.getGSILatestPartitionKey(model),
-        GSI1_SK: this.getGSISortKey(entry)
-      })));
-    }
-
-    try {
-      await this._table.batchWrite(items);
-      return storageEntry;
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not update entry.", ex.code || "UPDATE_ERROR", {
-        error: ex,
-        originalEntry,
-        entry,
-        latestStorageEntry
-      });
-    }
-  }
-
-  async publish(model, args) {
-    const {
-      entry,
-      storageEntry
-    } = args;
-    const partitionKey = this.getPartitionKey(entry.id);
-    /**
-     * We need the latest and published entries to see if something needs to be updated along side the publishing one.
-     */
-
-    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
-    const publishedStorageEntry = await this.getPublishedRevisionByEntryId(model, entry.id);
-    /**
-     * 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 = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyRevision(entry.version),
-      TYPE: TYPE_ENTRY,
-      GSI1_PK: this.getGSIEntryPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(entry)
-    })), this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyPublished(),
-      TYPE: TYPE_ENTRY_PUBLISHED,
-      GSI1_PK: this.getGSIPublishedPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(entry)
-    }))];
-
-    if (entry.id === latestStorageEntry.id) {
-      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: this.getSortKeyLatest(),
-        TYPE: TYPE_ENTRY_LATEST,
-        GSI1_PK: this.getGSILatestPartitionKey(model),
-        GSI1_SK: this.getGSISortKey(entry)
-      })));
-    }
-
-    if (publishedStorageEntry) {
-      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, publishedStorageEntry), {}, {
-        PK: partitionKey,
-        SK: this.getSortKeyRevision(publishedStorageEntry.version),
-        TYPE: TYPE_ENTRY,
-        status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
-        GSI1_PK: this.getGSIEntryPartitionKey(model),
-        GSI1_SK: this.getGSISortKey(publishedStorageEntry)
-      })));
-    }
-
-    try {
-      await this._table.batchWrite(items);
-
-      this._dataLoaders.clearAllEntryRevisions(model, entry);
-
-      return entry;
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not execute the publishing batch.", ex.code || "PUBLISH_ERROR", {
-        entry,
-        latestStorageEntry,
-        publishedStorageEntry
-      });
-    }
-  }
-
-  async unpublish(model, args) {
-    const {
-      entry,
-      storageEntry
-    } = args;
-    const partitionKey = this.getPartitionKey(entry.id);
-    /**
-     * 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 = [this._entity.deleteBatch({
-      PK: partitionKey,
-      SK: this.getSortKeyPublished()
-    }), this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyRevision(entry.version),
-      TYPE: TYPE_ENTRY,
-      GSI1_PK: this.getGSIEntryPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(entry)
-    }))];
-    /**
-     * We need the latest entry to see if something needs to be updated along side the unpublishing one.
-     */
-
-    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
-
-    if (entry.id === latestStorageEntry.id) {
-      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: this.getSortKeyLatest(),
-        TYPE: TYPE_ENTRY_LATEST,
-        GSI1_PK: this.getGSILatestPartitionKey(model),
-        GSI1_SK: this.getGSISortKey(entry)
-      })));
-    }
-
-    try {
-      await this._table.batchWrite(items);
-      return storageEntry;
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not execute unpublish batch.", ex.code || "UNPUBLISH_ERROR", {
-        entry,
-        storageEntry
-      });
-    }
-  }
-
-  async requestChanges(model, args) {
-    const {
-      entry,
-      storageEntry,
-      originalEntry
-    } = args;
-    const partitionKey = this.getPartitionKey(entry.id);
-    /**
-     * We need to:
-     *  - update the existing entry
-     *  - update latest version - if existing entry is the latest version
-     */
-
-    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyRevision(entry.version),
-      GSI1_PK: this.getGSIEntryPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(entry)
-    }))];
-    /**
-     * We need the latest entry to see if something needs to be updated along side the request changes one.
-     */
-
-    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
-
-    if (latestStorageEntry.id === entry.id) {
-      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: this.getSortKeyLatest(),
-        TYPE: TYPE_ENTRY_LATEST,
-        GSI1_PK: this.getGSILatestPartitionKey(model),
-        GSI1_SK: this.getGSISortKey(entry)
-      })));
-    }
-
-    try {
-      await this._table.batchWrite(items);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not execute the request changes batch.", ex.code || "REQUEST_CHANGES_ERROR", {
-        entry,
-        originalEntry
-      });
-    }
-
-    return entry;
-  }
-
-  async requestReview(model, args) {
-    const {
-      entry,
-      storageEntry,
-      originalEntry
-    } = args;
-    const partitionKey = this.getPartitionKey(entry.id);
-    /**
-     * We need to:
-     *  - update existing entry
-     *  - update latest entry - if existing entry is the latest entry
-     */
-
-    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-      PK: partitionKey,
-      SK: this.getSortKeyRevision(entry.version),
-      GSI1_PK: this.getGSIEntryPartitionKey(model),
-      GSI1_SK: this.getGSISortKey(entry)
-    }))];
-    /**
-     * We need the latest entry to see if something needs to be updated along side the request review one.
-     */
-
-    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
-
-    if (latestStorageEntry.id === entry.id) {
-      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
-        PK: partitionKey,
-        SK: this.getSortKeyLatest(),
-        TYPE: TYPE_ENTRY_LATEST,
-        GSI1_PK: this.getGSILatestPartitionKey(model),
-        GSI1_SK: this.getGSISortKey(entry)
-      })));
-    }
-
-    try {
-      await this._table.batchWrite(items);
-      return entry;
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not execute request review batch.", ex.code || "REQUEST_REVIEW_ERROR", {
-        entry,
-        storageEntry,
-        originalEntry
-      });
-    }
-  }
-
-  async getAllRevisionsByIds(model, ids) {
-    if (ids.length === 0) {
-      return [];
-    }
-
-    try {
-      return await this._dataLoaders.getAllEntryRevisions(model, ids);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_ALL_REVISIONS_BY_IDS_ERROR", {
-        ids
-      });
-    }
-  }
-
-  async getByIds(model, ids) {
-    if (ids.length === 0) {
-      return [];
-    }
-
-    try {
-      return await this._dataLoaders.getRevisionById(model, ids);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_BY_IDS_ERROR", {
-        ids
-      });
-    }
-  }
-
-  async getPublishedByIds(model, ids) {
-    if (ids.length === 0) {
-      return [];
-    }
-
-    try {
-      return await this._dataLoaders.getPublishedRevisionByEntryId(model, ids);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_BY_IDS_ERROR", {
-        ids
-      });
-    }
-  }
-
-  async getLatestByIds(model, ids) {
-    if (ids.length === 0) {
-      return [];
-    }
-
-    try {
-      return await this._dataLoaders.getLatestRevisionByEntryId(model, ids);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_BY_IDS_ERROR", {
-        ids
-      });
-    }
-  }
-
-  async getRevisions(model, id) {
-    try {
-      return await this._dataLoaders.getAllEntryRevisions(model, [id]);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_ALL_REVISIONS_BY_IDS_ERROR", {
-        id
-      });
-    }
-  }
-
-  async getRevisionById(model, id) {
-    return this.getSingleDynamoDbItem({
-      partitionKey: this.getPartitionKey(id),
-      value: this.getSortKeyRevision(id)
-    });
-  }
-
-  async getPublishedRevisionByEntryId(model, entryId) {
-    return this.getSingleDynamoDbItem({
-      partitionKey: this.getPartitionKey(entryId),
-      value: this.getSortKeyPublished()
-    });
-  }
-
-  async getLatestRevisionByEntryId(model, entryId) {
-    return this.getSingleDynamoDbItem({
-      partitionKey: this.getPartitionKey(entryId),
-      value: this.getSortKeyLatest()
-    });
-  }
-
-  async getPreviousRevision(model, entryId, version) {
-    const entry = await this.getSingleDynamoDbItem({
-      partitionKey: this.getPartitionKey(entryId),
-      op: "lt",
-      value: this.getSortKeyRevision(version),
-      order: "DESC"
-    });
-
-    if (entry.TYPE !== TYPE_ENTRY) {
-      return null;
-    }
-
-    return entry;
-  }
-
-  async getSingleDynamoDbItem(args) {
-    const {
-      partitionKey,
-      op = "eq",
-      value,
-      order = "ASC"
-    } = args;
-    const queryOptions = {
-      [op]: value,
-      reverse: order === "DESC",
-      limit: 1
-    };
-
-    try {
-      const result = await this._entity.query(partitionKey, queryOptions);
-
-      if (!result || Array.isArray(result.Items) === false) {
-        throw new _error.default("Error when querying for content entries - no result.", "QUERY_ERROR", {
-          partitionKey,
-          queryOptions
-        });
-      }
-
-      if (result.Items.length === 0) {
-        return null;
-      }
-
-      return result.Items.shift();
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not read from the DynamoDB.", ex.code || "DDB_READ_ERROR", {
-        partitionKey,
-        queryOptions
-      });
-    }
-  }
-
-  getPartitionKey(id) {
-    /**
-     * If ID includes # it means it is composed of ID and VERSION.
-     * We need ID only so extract it.
-     */
-    if (id.match("#") !== null) {
-      id = id.split("#").shift();
-    }
-
-    return `${this.partitionKey}#${id}`;
-  }
-
-  get partitionKey() {
-    return `${(0, _utils2.createBasePartitionKey)(this.context)}#CME`;
-  }
-
-  getGSIPartitionKey(type, model) {
-    return `${this.partitionKey}#M#${model.modelId}#${type}`;
-  }
-
-  getGSIEntryPartitionKey(model) {
-    return this.getGSIPartitionKey("A", model);
-  }
-
-  getGSILatestPartitionKey(model) {
-    return this.getGSIPartitionKey("L", model);
-  }
-
-  getGSIPublishedPartitionKey(model) {
-    return this.getGSIPartitionKey("P", model);
-  }
-
-  getGSISortKey(entry) {
-    return entry.id;
-  }
-  /**
-   * Gets a secondary key in form of REV#version from:
-   *   id#0003
-   *   0003
-   *   3
-   */
-
-
-  getSortKeyRevision(version) {
-    if (typeof version === "string" && version.includes("#") === true) {
-      version = version.split("#").pop();
-    }
-
-    return `REV#${(0, _utils.zeroPad)(version)}`;
-  }
-
-  getSortKeyLatest() {
-    return "L";
-  }
-
-  getSortKeyPublished() {
-    return "P";
-  }
-  /**
-   * Method to build the query partition keys, always an array, and create the target index:
-   * - if undefined then it is primary
-   * - if populated then it is that given one (and partition keys are reflecting that)
-   */
-
-
-  createQueryOptions({
-    where: originalWhere,
-    model
-  }) {
-    const options = {
-      filters: [],
-      index: undefined
-    };
-    const where = (0, _lodash.default)(originalWhere);
-    /**
-     * if we have id or entry ID, we will query via the primary key
-     * just add all the possible IDs to find
-     */
-
-    const queryPartitionKeys = [];
-
-    if (where.id) {
-      queryPartitionKeys.push(this.getPartitionKey(where.id));
-    }
-
-    if (where.entryId) {
-      queryPartitionKeys.push(this.getPartitionKey(where.entryId));
-    }
-
-    if (where.id_in) {
-      queryPartitionKeys.push(...where.id_in.map(id => this.getPartitionKey(id)));
-    }
-
-    if (where.entryId_in) {
-      queryPartitionKeys.push(...where.entryId_in.map(id => this.getPartitionKey(id)));
-    }
-    /**
-     * If we do not have any of the IDs, we will query via the GSI1_PK just depending on the entry type
-     * At this point there will probably be a lot of results
-     * but we will apply some basic dynamodb filters so we dont get much data from the db
-     * NOTE: It is still going to get charged tho
-     */
-
-
-    if (queryPartitionKeys.length === 0) {
-      options.index = GSI1_INDEX;
-
-      if (where.published) {
-        queryPartitionKeys.push(this.getGSIPartitionKey("P", model));
-      } else if (where.latest) {
-        queryPartitionKeys.push(this.getGSIPartitionKey("L", model));
-      } else {
-        queryPartitionKeys.push(this.getGSIPartitionKey("A", model));
-      }
-    }
-    /**
-     * If index is the primary one, we can filter records by type (latest, published or regular)
-     * so we do not need to filter in the code
-     */
-
-
-    if (!options.index) {
-      if (where.published) {
-        options.eq = this.getSortKeyPublished();
-      } else if (where.latest) {
-        options.eq = this.getSortKeyLatest();
-      } else {
-        options.beginsWith = "REV#";
-      }
-    }
-    /**
-     * we remove all the used where conditions
-     */
-
-
-    delete where["id"];
-    delete where["id_in"];
-    delete where["entryId"];
-    delete where["entryId_in"];
-    delete where["published"];
-    delete where["latest"];
-    return {
-      options,
-      queryPartitionKeys,
-      where
-    };
-  }
-  /**
-   * A method to query the database at the given partition key with the built query options.
-   * Method runs in the loop until it reads everything it needs to.
-   * We could impose the limit on the records read but there is no point since we MUST read everything to be able
-   * to filter and sort the data.
-   */
-
-
-  async runQuery(args) {
-    let previousResult = undefined;
-    let results;
-    const items = [];
-
-    while (results = await this.query(previousResult, args)) {
-      items.push(...results.Items);
-      previousResult = results;
-    }
-
-    return items;
-  }
-
-  async query(previousResult, args) {
-    const {
-      partitionKey,
-      options
-    } = args;
-    let result;
-    /**
-     * In case there is no previous result we must make a new query.
-     * This is the first query on the given partition key.
-     */
-
-    if (!previousResult) {
-      result = await this._entity.query(partitionKey, options);
-    } else if (typeof previousResult.next === "function") {
-      /**
-       * In case we have a previous result and it has a next method, we run it.
-       * In case result of the next method is false, it means it has nothing else to read
-       * and we return a null to keep the query from repeating.
-       */
-      result = await previousResult.next();
-
-      if (result === false) {
-        return null;
-      }
-    } else {
-      /**
-       * This could probably never happen but keep it here just in case to break the query loop.
-       * Basically, either previousResult does not exist or it exists and has a next method
-       * and at that point a result returned will be null and loop should not start again.
-       */
-      return null;
-    }
-    /**
-     * We expect the result to contain an Items array and if not, something went wrong, very wrong.
-     */
-
-
-    if (!result || !result.Items || !Array.isArray(result.Items)) {
-      throw new _error.default("Error when querying for content entries - no result.", "QUERY_ERROR", {
-        partitionKey,
-        options
-      });
-    }
-
-    return result;
-  }
-
-}
-
-exports.CmsContentEntryDynamo = CmsContentEntryDynamo;
-//# sourceMappingURL=CmsContentEntryDynamo.js.map