@webiny/api-headless-cms 0.0.0-unstable.990c3ab1b6 → 0.0.0-unstable.99666aeb00

package/crud/contentEntry.crud.js

@@ -6,32 +6,27 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createContentEntryCrud = exports.STATUS_UNPUBLISHED = exports.STATUS_PUBLISHED = exports.STATUS_DRAFT = void 0;
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-var _mdbid = _interopRequireDefault(require("mdbid"));
+var _merge = _interopRequireDefault(require("lodash/merge"));
+var _utils = require("@webiny/utils");
+var _error = _interopRequireDefault(require("@webiny/error"));
 var _handlerGraphql = require("@webiny/handler-graphql");
+var _types = require("../types");
 var _entryDataValidation = require("./contentEntry/entryDataValidation");
-var _error = _interopRequireDefault(require("@webiny/error"));
 var _pubsub = require("@webiny/pubsub");
 var _beforeCreate = require("./contentEntry/beforeCreate");
 var _beforeUpdate = require("./contentEntry/beforeUpdate");
-var _utils = require("@webiny/utils");
 var _afterDelete = require("./contentEntry/afterDelete");
 var _referenceFieldsMapping = require("./contentEntry/referenceFieldsMapping");
-var _merge = _interopRequireDefault(require("lodash/merge"));
-var _permissions = require("../utils/permissions");
-var _access = require("../utils/access");
-var _ownership = require("../utils/ownership");
 var _entryStorage = require("../utils/entryStorage");
-var _valueKeyStorageConverter = require("../utils/converters/valueKeyStorageConverter");
-/**
- * Package mdbid does not have types.
- */
-// @ts-ignore
-
-const STATUS_DRAFT = "draft";
+var _searchableFields = require("./contentEntry/searchableFields");
+var _filterAsync = require("../utils/filterAsync");
+var _apiSecurity = require("@webiny/api-security/");
+var _constants = require("../constants");
+const STATUS_DRAFT = _types.CONTENT_ENTRY_STATUS.DRAFT;
 exports.STATUS_DRAFT = STATUS_DRAFT;
-const STATUS_PUBLISHED = "published";
+const STATUS_PUBLISHED = _types.CONTENT_ENTRY_STATUS.PUBLISHED;
 exports.STATUS_PUBLISHED = STATUS_PUBLISHED;
-const STATUS_UNPUBLISHED = "unpublished";
+const STATUS_UNPUBLISHED = _types.CONTENT_ENTRY_STATUS.UNPUBLISHED;
 exports.STATUS_UNPUBLISHED = STATUS_UNPUBLISHED;
 /**
  * Used for some fields to convert their values.
@@ -130,16 +125,19 @@ const mapAndCleanUpdatedInputData = (model, input) => {
  */
 const createEntryMeta = (input, original) => {
   const meta = (0, _merge.default)(original || {}, input || {});
-  for (const key in meta) {
-    if (meta[key] !== undefined || meta[key] !== null) {
-      continue;
+  return (0, _utils.removeUndefinedValues)((0, _utils.removeNullValues)(meta));
+};
+const createEntryId = input => {
+  let entryId = (0, _utils.mdbid)();
+  if (input.id) {
+    if (input.id.match(/^([a-zA-Z0-9])([a-zA-Z0-9\-]+)([a-zA-Z0-9])$/) === null) {
+      throw new _error.default("The provided ID is not valid. It must be a string which can be A-Z, a-z, 0-9, - and it cannot start or end with a -.", "INVALID_ID", {
+        id: input.id
+      });
     }
-    delete meta[key];
+    entryId = input.id;
   }
-  return meta;
-};
-const createEntryId = version => {
-  const entryId = (0, _mdbid.default)();
+  const version = 1;
   return {
     entryId,
     version,
@@ -168,85 +166,107 @@ const increaseEntryIdVersion = id => {
     })
   };
 };
-const getSearchableFields = params => {
-  const {
-    plugins,
-    model,
-    fields
-  } = params;
-  const fieldPluginMap = plugins.byType("cms-model-field-to-graphql").reduce((collection, field) => {
-    collection[field.fieldType] = field;
-    return collection;
-  }, {});
-  return model.fields.filter(field => {
-    if (!field.fieldId) {
-      return false;
-    }
-    const plugin = fieldPluginMap[field.type];
-    if (!plugin) {
-      return false;
-    } else if (!plugin.fullTextSearch) {
-      return false;
-    } else if (!fields || fields.length === 0) {
-      return true;
-    }
-    return fields.includes(field.fieldId);
-  }).map(field => field.fieldId);
-};
 const allowedEntryStatus = ["draft", "published", "unpublished"];
 const transformEntryStatus = status => {
   return allowedEntryStatus.includes(status) ? status : "draft";
 };
+const createSort = sort => {
+  if (!Array.isArray(sort)) {
+    return ["createdOn_DESC"];
+  } else if (sort.filter(s => !!s).length === 0) {
+    return ["createdOn_DESC"];
+  }
+  return sort;
+};
 const createContentEntryCrud = params => {
   const {
     storageOperations,
+    entriesPermissions,
+    modelsPermissions,
     context,
     getIdentity,
-    getTenant
+    getTenant,
+    getLocale
   } = params;
-  const {
-    plugins
-  } = context;
+  const getCreatedBy = () => {
+    const identity = getIdentity();
+    return {
+      id: identity.id,
+      displayName: identity.displayName,
+      type: identity.type
+    };
+  };
 
-  // create
+  /**
+   * Create
+   */
   const onEntryBeforeCreate = (0, _pubsub.createTopic)("cms.onEntryBeforeCreate");
   const onEntryAfterCreate = (0, _pubsub.createTopic)("cms.onEntryAfterCreate");
   const onEntryCreateError = (0, _pubsub.createTopic)("cms.onEntryCreateError");
 
-  // create revision
+  /**
+   * Create new revision
+   */
   const onEntryBeforeCreateRevision = (0, _pubsub.createTopic)("cms.onEntryBeforeCreateRevision");
   const onEntryRevisionAfterCreate = (0, _pubsub.createTopic)("cms.onEntryRevisionAfterCreate");
   const onEntryCreateRevisionError = (0, _pubsub.createTopic)("cms.onEntryCreateRevisionError");
 
-  // update
+  /**
+   * Update
+   */
   const onEntryBeforeUpdate = (0, _pubsub.createTopic)("cms.onEntryBeforeUpdate");
   const onEntryAfterUpdate = (0, _pubsub.createTopic)("cms.onEntryAfterUpdate");
   const onEntryUpdateError = (0, _pubsub.createTopic)("cms.onEntryUpdateError");
 
-  // publish
+  /**
+   * Publish
+   */
   const onEntryBeforePublish = (0, _pubsub.createTopic)("cms.onEntryBeforePublish");
-  const onEntryAfterPublish = (0, _pubsub.createTopic)("cms.onEntryAfterPublic");
+  const onEntryAfterPublish = (0, _pubsub.createTopic)("cms.onEntryAfterPublish");
   const onEntryPublishError = (0, _pubsub.createTopic)("cms.onEntryPublishError");
 
-  // unpublish
+  /**
+   * Republish
+   */
+  const onEntryBeforeRepublish = (0, _pubsub.createTopic)("cms.onEntryBeforeRepublish");
+  const onEntryAfterRepublish = (0, _pubsub.createTopic)("cms.onEntryAfterRepublish");
+  const onEntryRepublishError = (0, _pubsub.createTopic)("cms.onEntryRepublishError");
+
+  /**
+   * Unpublish
+   */
   const onEntryBeforeUnpublish = (0, _pubsub.createTopic)("cms.onEntryBeforeUnpublish");
   const onEntryAfterUnpublish = (0, _pubsub.createTopic)("cms.onEntryAfterUnpublish");
   const onEntryUnpublishError = (0, _pubsub.createTopic)("cms.onEntryUnpublishError");
 
-  // delete
+  /**
+   * Delete
+   */
   const onEntryBeforeDelete = (0, _pubsub.createTopic)("cms.onEntryBeforeDelete");
   const onEntryAfterDelete = (0, _pubsub.createTopic)("cms.onEntryAfterDelete");
   const onEntryDeleteError = (0, _pubsub.createTopic)("cms.onEntryDeleteError");
 
-  // delete revision
+  /**
+   * Delete revision
+   */
   const onEntryRevisionBeforeDelete = (0, _pubsub.createTopic)("cms.onEntryRevisionBeforeDelete");
   const onEntryRevisionAfterDelete = (0, _pubsub.createTopic)("cms.onEntryRevisionAfterDelete");
   const onEntryRevisionDeleteError = (0, _pubsub.createTopic)("cms.onEntryRevisionDeleteError");
+  /**
+   * Delete multiple entries
+   */
+  const onEntryBeforeDeleteMultiple = (0, _pubsub.createTopic)("cms.onEntryBeforeDeleteMultiple");
+  const onEntryAfterDeleteMultiple = (0, _pubsub.createTopic)("cms.onEntryAfterDeleteMultiple");
+  const onEntryDeleteMultipleError = (0, _pubsub.createTopic)("cms.onEntryDeleteMultipleError");
 
-  // get
+  /**
+   * Get entry
+   */
   const onEntryBeforeGet = (0, _pubsub.createTopic)("cms.onEntryBeforeGet");
 
-  // list
+  /**
+   * List entries
+   */
   const onEntryBeforeList = (0, _pubsub.createTopic)("cms.onEntryBeforeList");
 
   /**
@@ -264,286 +284,1119 @@ const createContentEntryCrud = params => {
     context,
     onEntryAfterDelete
   });
-  const checkEntryPermissions = check => {
-    return (0, _permissions.checkPermissions)(context, "cms.contentEntry", check);
-  };
 
   /**
    * A helper to delete the entire entry.
    */
-  const deleteEntry = async params => {
-    const {
-      model,
-      entry
-    } = params;
-    try {
-      await onEntryBeforeDelete.publish({
-        entry,
-        model
-      });
-      await storageOperations.entries.delete(model, {
+  const deleteEntryHelper = async params => {
+    return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async () => {
+      const {
+        model,
         entry
+      } = params;
+      try {
+        await onEntryBeforeDelete.publish({
+          entry,
+          model
+        });
+        await storageOperations.entries.delete(model, {
+          entry
+        });
+        await onEntryAfterDelete.publish({
+          entry,
+          model
+        });
+      } catch (ex) {
+        await onEntryDeleteError.publish({
+          entry,
+          model,
+          error: ex
+        });
+        throw new _error.default(ex.message || "Could not delete entry.", ex.code || "DELETE_ERROR", {
+          entry
+        });
+      }
+    });
+  };
+  /**
+   * A helper to get entries by revision IDs
+   */
+  const getEntriesByIds = async (model, ids) => {
+    return context.benchmark.measure("headlessCms.crud.entries.getEntriesByIds", async () => {
+      await entriesPermissions.ensure({
+        rwd: "r"
       });
-      await onEntryAfterDelete.publish({
-        entry,
-        model
-      });
-    } catch (ex) {
-      await onEntryDeleteError.publish({
-        entry,
+      await modelsPermissions.ensureCanAccessModel({
         model,
-        error: ex
+        locale: getLocale().code
       });
-      throw new _error.default(ex.message || "Could not delete entry.", ex.code || "DELETE_ERROR", {
-        entry
+      const entries = await storageOperations.entries.getByIds(model, {
+        ids
+      });
+      return (0, _filterAsync.filterAsync)(entries, async entry => {
+        return entriesPermissions.ensure({
+          owns: entry.createdBy
+        }, {
+          throw: false
+        });
       });
+    });
+  };
+  const getEntryById = async (model, id) => {
+    const where = {
+      id
+    };
+    await onEntryBeforeGet.publish({
+      where,
+      model
+    });
+    const [entry] = await getEntriesByIds(model, [id]);
+    if (!entry) {
+      throw new _handlerGraphql.NotFoundError(`Entry by ID "${id}" not found.`);
     }
+    return entry;
   };
-  /**
-   * A helper to get entries by revision IDs
-   */
-  const getEntriesByIds = async (initialModel, ids) => {
-    const permission = await checkEntryPermissions({
+  const getPublishedEntriesByIds = async (model, ids) => {
+    await entriesPermissions.ensure({
       rwd: "r"
     });
-    await (0, _access.checkModelAccess)(context, initialModel);
-    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-      model: initialModel,
-      plugins
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
     });
-    const entries = await storageOperations.entries.getByIds(model, {
+    const entries = await storageOperations.entries.getPublishedByIds(model, {
       ids
     });
-    return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
-  };
-  return {
-    /**
-     * Deprecated - will be removed in 5.35.0
-     */
-    onBeforeEntryCreate: onEntryBeforeCreate,
-    onAfterEntryCreate: onEntryAfterCreate,
-    onBeforeEntryCreateRevision: onEntryBeforeCreateRevision,
-    onAfterEntryCreateRevision: onEntryRevisionAfterCreate,
-    onBeforeEntryUpdate: onEntryBeforeUpdate,
-    onAfterEntryUpdate: onEntryAfterUpdate,
-    onBeforeEntryDelete: onEntryBeforeDelete,
-    onAfterEntryDelete: onEntryAfterDelete,
-    onBeforeEntryDeleteRevision: onEntryRevisionBeforeDelete,
-    onAfterEntryDeleteRevision: onEntryRevisionAfterDelete,
-    onBeforeEntryPublish: onEntryBeforePublish,
-    onAfterEntryPublish: onEntryAfterPublish,
-    onBeforeEntryUnpublish: onEntryBeforeUnpublish,
-    onAfterEntryUnpublish: onEntryAfterUnpublish,
-    onBeforeEntryGet: onEntryBeforeGet,
-    onBeforeEntryList: onEntryBeforeList,
-    /**
-     * Released in 5.34.0
-     */
-    onEntryBeforeCreate,
-    onEntryAfterCreate,
-    onEntryCreateError,
-    onEntryRevisionBeforeCreate: onEntryBeforeCreateRevision,
-    onEntryRevisionAfterCreate,
-    onEntryRevisionCreateError: onEntryCreateRevisionError,
-    onEntryBeforeUpdate,
-    onEntryAfterUpdate,
-    onEntryUpdateError,
-    onEntryBeforeDelete,
-    onEntryAfterDelete,
-    onEntryDeleteError,
-    onEntryRevisionBeforeDelete,
-    onEntryRevisionAfterDelete,
-    onEntryRevisionDeleteError,
-    onEntryBeforePublish,
-    onEntryAfterPublish,
-    onEntryPublishError,
-    onEntryBeforeUnpublish,
-    onEntryAfterUnpublish,
-    onEntryUnpublishError,
-    onEntryBeforeGet,
-    onEntryBeforeList,
-    /**
-     * Get entries by exact revision IDs from the database.
-     */
-    getEntriesByIds: getEntriesByIds,
-    /**
-     * Get a single entry by revision ID from the database.
-     */
-    async getEntryById(initialModel, id) {
-      const where = {
-        id
-      };
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
+    return (0, _filterAsync.filterAsync)(entries, async entry => {
+      return entriesPermissions.ensure({
+        owns: entry.createdBy
+      }, {
+        throw: false
       });
-      await onEntryBeforeGet.publish({
-        where,
-        model
+    });
+  };
+  const getLatestEntriesByIds = async (model, ids) => {
+    await entriesPermissions.ensure({
+      rwd: "r"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+    const entries = await storageOperations.entries.getLatestByIds(model, {
+      ids
+    });
+    return (0, _filterAsync.filterAsync)(entries, async entry => {
+      return entriesPermissions.ensure({
+        owns: entry.createdBy
+      }, {
+        throw: false
       });
-      const [entry] = await getEntriesByIds(model, [id]);
-      if (!entry) {
-        throw new _handlerGraphql.NotFoundError(`Entry by ID "${id}" not found.`);
-      }
-      return entry;
-    },
-    /**
-     * Get published revisions by entry IDs.
-     */
-    async getPublishedEntriesByIds(initialModel, ids) {
-      const permission = await checkEntryPermissions({
+    });
+  };
+  const getEntry = async (model, params) => {
+    await entriesPermissions.ensure({
+      rwd: "r"
+    });
+    const {
+      where,
+      sort
+    } = params;
+    await onEntryBeforeGet.publish({
+      where,
+      model
+    });
+    const [items] = await listEntries(model, {
+      where,
+      sort,
+      limit: 1
+    });
+    const item = items.shift();
+    if (!item) {
+      throw new _handlerGraphql.NotFoundError(`Entry not found!`);
+    }
+    return item;
+  };
+  const getEntryRevisions = async (model, entryId) => {
+    return storageOperations.entries.getRevisions(model, {
+      id: entryId
+    });
+  };
+  const listEntries = async (model, params) => {
+    try {
+      await entriesPermissions.ensure({
         rwd: "r"
       });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-      const entries = await storageOperations.entries.getPublishedByIds(model, {
-        ids
+    } catch {
+      throw new _apiSecurity.NotAuthorizedError({
+        data: {
+          reason: 'Not allowed to perform "read" on "cms.contentEntry".'
+        }
       });
-      return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
-    },
+    }
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+    const {
+      where: initialWhere,
+      limit: initialLimit
+    } = params;
+    const limit = initialLimit && initialLimit > 0 ? initialLimit : 50;
+    const where = (0, _objectSpread2.default)({}, initialWhere);
     /**
-     * Get latest revisions by entry IDs.
+     * Possibly only get records which are owned by current user.
+     * Or if searching for the owner set that value - in the case that user can see other entries than their own.
      */
-    async getLatestEntriesByIds(initialModel, ids) {
-      const permission = await checkEntryPermissions({
-        rwd: "r"
-      });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-      const entries = await storageOperations.entries.getLatestByIds(model, {
-        ids
-      });
-      return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
-    },
-    async getEntryRevisions(initialModel, entryId) {
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-      return storageOperations.entries.getRevisions(model, {
-        id: entryId
-      });
-    },
+    if (await entriesPermissions.canAccessOnlyOwnRecords()) {
+      where.ownedBy = getIdentity().id;
+    }
+
     /**
-     * TODO determine if this method is required at all.
-     *
-     * @internal
+     * Where must contain either latest or published keys.
+     * We cannot list entries without one of those
      */
-    async getEntry(initialModel, params) {
-      await checkEntryPermissions({
-        rwd: "r"
+    if (where.latest && where.published) {
+      throw new _error.default("Cannot list entries that are both published and latest.", "LIST_ENTRIES_ERROR", {
+        where
       });
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
+    } else if (!where.latest && !where.published) {
+      throw new _error.default("Cannot list entries if we do not have latest or published defined.", "LIST_ENTRIES_ERROR", {
+        where
       });
-      const {
-        where,
-        sort
-      } = params;
-      await onEntryBeforeGet.publish({
+    }
+    const fields = (0, _searchableFields.getSearchableFields)({
+      fields: model.fields,
+      plugins: context.plugins,
+      input: params.fields || []
+    });
+    try {
+      await onEntryBeforeList.publish({
         where,
         model
       });
-      const [items] = await this.listEntries(model, {
+      const {
+        hasMoreItems,
+        totalCount,
+        cursor,
+        items
+      } = await storageOperations.entries.list(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
+        sort: createSort(params.sort),
+        limit,
         where,
-        sort,
-        limit: 1
+        fields
+      }));
+      const meta = {
+        hasMoreItems,
+        totalCount,
+        /**
+         * Cursor should be null if there are no more items to load.
+         * Just make sure of that, disregarding what is returned from the storageOperations.entries.list method.
+         */
+        cursor: hasMoreItems ? cursor : null
+      };
+      return [items, meta];
+    } catch (ex) {
+      throw new _error.default("Error while fetching entries from storage.", "LIST_ENTRIES_ERROR", {
+        params,
+        error: {
+          message: ex.message,
+          code: ex.code,
+          data: ex.data
+        },
+        model,
+        fields
       });
-      if (items.length === 0) {
-        throw new _handlerGraphql.NotFoundError(`Entry not found!`);
-      }
-      return items[0];
-    },
+    }
+  };
+  const createEntry = async (model, inputData) => {
+    var _inputData$wbyAco_loc;
+    await entriesPermissions.ensure({
+      rwd: "w"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+
     /**
-     * @description Should not be used directly. Internal use only!
-     *
-     * @internal
+     * Make sure we only work with fields that are defined in the model.
      */
-    async listEntries(initialModel, params) {
-      const permission = await checkEntryPermissions({
-        rwd: "r"
+    const initialInput = mapAndCleanCreateInputData(model, inputData);
+    await (0, _entryDataValidation.validateModelEntryData)({
+      context,
+      model,
+      data: initialInput
+    });
+    const input = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+      context,
+      model,
+      input: initialInput,
+      validateEntries: true
+    });
+    const locale = getLocale();
+    const owner = getCreatedBy();
+    const {
+      id,
+      entryId,
+      version
+    } = createEntryId(inputData);
+    /**
+     * There is a possibility that user sends an ID in the input, so we will use that one.
+     * There is no check if the ID is unique or not, that is up to the user.
+     */
+    const entry = {
+      webinyVersion: context.WEBINY_VERSION,
+      tenant: getTenant().id,
+      entryId,
+      id,
+      modelId: model.modelId,
+      locale: locale.code,
+      createdOn: new Date().toISOString(),
+      savedOn: new Date().toISOString(),
+      createdBy: owner,
+      ownedBy: owner,
+      modifiedBy: null,
+      version,
+      locked: false,
+      status: STATUS_DRAFT,
+      values: input,
+      location: {
+        folderId: ((_inputData$wbyAco_loc = inputData.wbyAco_location) === null || _inputData$wbyAco_loc === void 0 ? void 0 : _inputData$wbyAco_loc.folderId) || _constants.ROOT_FOLDER
+      }
+    };
+    let storageEntry = null;
+    try {
+      await onEntryBeforeCreate.publish({
+        entry,
+        input,
+        model
       });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
+      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+      const result = await storageOperations.entries.create(model, {
+        entry,
+        storageEntry
       });
-      const {
-        where: initialWhere
-      } = params;
-      /**
-       * We always assign tenant and locale because we do not allow one model to have content through multiple tenants.
-       */
-      const where = (0, _objectSpread2.default)({}, initialWhere);
-      /**
-       * Possibly only get records which are owned by current user.
-       * Or if searching for the owner set that value - in the case that user can see other entries than their own.
-       */
-      const ownedBy = permission.own ? getIdentity().id : where.ownedBy;
-      if (ownedBy !== undefined) {
-        where.ownedBy = ownedBy;
-      }
-      /**
-       * Where must contain either latest or published keys.
-       * We cannot list entries without one of those
-       */
-      if (where.latest && where.published) {
-        throw new _error.default("Cannot list entries that are both published and latest.", "LIST_ENTRIES_ERROR", {
-          where
-        });
-      } else if (!where.latest && !where.published) {
-        throw new _error.default("Cannot list entries if we do not have latest or published defined.", "LIST_ENTRIES_ERROR", {
-          where
-        });
-      }
-      const fields = getSearchableFields({
+      await onEntryAfterCreate.publish({
+        entry,
+        storageEntry: result,
         model,
-        plugins: context.plugins,
-        fields: params.fields || []
+        input
+      });
+      return result;
+    } catch (ex) {
+      await onEntryCreateError.publish({
+        error: ex,
+        entry,
+        model,
+        input
+      });
+      throw new _error.default(ex.message || "Could not create content entry.", ex.code || "CREATE_ENTRY_ERROR", ex.data || {
+        error: ex,
+        input,
+        entry,
+        storageEntry
+      });
+    }
+  };
+  const createEntryRevisionFrom = async (model, sourceId, inputData) => {
+    await entriesPermissions.ensure({
+      rwd: "w"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+
+    /**
+     * Make sure we only work with fields that are defined in the model.
+     */
+    const input = mapAndCleanUpdatedInputData(model, inputData);
+
+    /**
+     * Entries are identified by a common parent ID + Revision number.
+     */
+    const {
+      id: uniqueId
+    } = (0, _utils.parseIdentifier)(sourceId);
+    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+      id: sourceId
+    });
+    const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+      id: uniqueId
+    });
+    if (!originalStorageEntry) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${sourceId}" of model "${model.modelId}" was not found.`);
+    }
+
+    /**
+     * We need to convert data from DB to its original form before using it further.
+     */
+    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
+    await (0, _entryDataValidation.validateModelEntryData)({
+      context,
+      model,
+      data: initialValues,
+      entry: originalEntry
+    });
+    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+      context,
+      model,
+      input: initialValues,
+      validateEntries: false
+    });
+    await entriesPermissions.ensure({
+      owns: originalEntry.createdBy
+    });
+    const identity = getIdentity();
+    const latestId = latestStorageEntry ? latestStorageEntry.id : sourceId;
+    const {
+      id,
+      version: nextVersion
+    } = increaseEntryIdVersion(latestId);
+    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+      id,
+      version: nextVersion,
+      savedOn: new Date().toISOString(),
+      createdOn: new Date().toISOString(),
+      createdBy: {
+        id: identity.id,
+        displayName: identity.displayName,
+        type: identity.type
+      },
+      modifiedBy: null,
+      locked: false,
+      publishedOn: undefined,
+      status: STATUS_DRAFT,
+      values
+    });
+    let storageEntry = null;
+    try {
+      await onEntryBeforeCreateRevision.publish({
+        input,
+        entry,
+        original: originalEntry,
+        model
+      });
+      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+      const result = await storageOperations.entries.createRevisionFrom(model, {
+        entry,
+        storageEntry
+      });
+      await onEntryRevisionAfterCreate.publish({
+        input,
+        entry,
+        model,
+        original: originalEntry,
+        storageEntry: result
+      });
+      return result;
+    } catch (ex) {
+      await onEntryCreateRevisionError.publish({
+        entry,
+        original: originalEntry,
+        model,
+        input,
+        error: ex
+      });
+      throw new _error.default(ex.message || "Could not create entry from existing one.", ex.code || "CREATE_FROM_REVISION_ERROR", {
+        error: ex,
+        entry,
+        storageEntry,
+        originalEntry,
+        originalStorageEntry
+      });
+    }
+  };
+  const updateEntry = async (model, id, inputData, metaInput) => {
+    var _inputData$wbyAco_loc2;
+    await entriesPermissions.ensure({
+      rwd: "w"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+
+    /**
+     * Make sure we only work with fields that are defined in the model.
+     */
+    const input = mapAndCleanUpdatedInputData(model, inputData);
+
+    /**
+     * The entry we are going to update.
+     */
+    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+      id
+    });
+    if (!originalStorageEntry) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
+    }
+    if (originalStorageEntry.locked) {
+      throw new _error.default(`Cannot update entry because it's locked.`, "CONTENT_ENTRY_UPDATE_ERROR");
+    }
+    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    await (0, _entryDataValidation.validateModelEntryData)({
+      context,
+      model,
+      data: input,
+      entry: originalEntry
+    });
+    await entriesPermissions.ensure({
+      owns: originalEntry.createdBy
+    });
+    const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
+    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+      context,
+      model,
+      input: initialValues,
+      validateEntries: false
+    });
+    /**
+     * If users wants to remove a key from meta values, they need to send meta key with the null value.
+     */
+    const meta = createEntryMeta(metaInput, originalEntry.meta);
+    /**
+     * We always send the full entry to the hooks and storage operations update.
+     */
+    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+      savedOn: new Date().toISOString(),
+      modifiedBy: getCreatedBy(),
+      values,
+      meta,
+      status: transformEntryStatus(originalEntry.status)
+    });
+    const folderId = (_inputData$wbyAco_loc2 = inputData.wbyAco_location) === null || _inputData$wbyAco_loc2 === void 0 ? void 0 : _inputData$wbyAco_loc2.folderId;
+    if (folderId) {
+      entry.location = {
+        folderId
+      };
+    }
+    let storageEntry = null;
+    try {
+      await onEntryBeforeUpdate.publish({
+        entry,
+        model,
+        input,
+        original: originalEntry
+      });
+      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+      const result = await storageOperations.entries.update(model, {
+        entry,
+        storageEntry
+      });
+      await onEntryAfterUpdate.publish({
+        entry,
+        storageEntry: result,
+        model,
+        input,
+        original: originalEntry
+      });
+      return result;
+    } catch (ex) {
+      await onEntryUpdateError.publish({
+        entry,
+        model,
+        input,
+        error: ex
+      });
+      throw new _error.default(ex.message || "Could not update existing entry.", ex.code || "UPDATE_ERROR", {
+        error: ex,
+        entry,
+        storageEntry,
+        originalEntry,
+        input
+      });
+    }
+  };
+  const republishEntry = async (model, id) => {
+    await entriesPermissions.ensure({
+      rwd: "w"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+
+    /**
+     * Fetch the entry from the storage.
+     */
+    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+      id
+    });
+    if (!originalStorageEntry) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${id}" was not found!`);
+    }
+    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    /**
+     * We can only process published entries.
+     */
+    if (originalEntry.status !== "published") {
+      throw new _error.default("Entry with given ID is not published!", "NOT_PUBLISHED_ERROR", {
+        id,
+        original: originalEntry
+      });
+    }
+    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+      context,
+      model,
+      input: originalEntry.values,
+      validateEntries: false
+    });
+    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+      savedOn: new Date().toISOString(),
+      webinyVersion: context.WEBINY_VERSION,
+      values
+    });
+    const storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+    /**
+     * First we need to update existing entry.
+     */
+    try {
+      await storageOperations.entries.update(model, {
+        entry,
+        storageEntry
+      });
+    } catch (ex) {
+      throw new _error.default("Could not update existing entry with new data while re-publishing.", "REPUBLISH_UPDATE_ERROR", {
+        entry
+      });
+    }
+    /**
+     * Then we move onto publishing it again.
+     */
+    try {
+      await onEntryBeforeRepublish.publish({
+        entry,
+        model
+      });
+      const result = await storageOperations.entries.publish(model, {
+        entry,
+        storageEntry
+      });
+      await onEntryAfterRepublish.publish({
+        entry,
+        model,
+        storageEntry
+      });
+      return result;
+    } catch (ex) {
+      await onEntryRepublishError.publish({
+        entry,
+        model,
+        error: ex
+      });
+      throw new _error.default("Could not publish existing entry while re-publishing.", "REPUBLISH_PUBLISH_ERROR", {
+        entry
+      });
+    }
+  };
+  const deleteEntryRevision = async (model, revisionId) => {
+    await entriesPermissions.ensure({
+      rwd: "d"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+    const {
+      id: entryId,
+      version
+    } = (0, _utils.parseIdentifier)(revisionId);
+    const storageEntryToDelete = await storageOperations.entries.getRevisionById(model, {
+      id: revisionId
+    });
+    const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+      id: entryId
+    });
+    const previousStorageEntry = await storageOperations.entries.getPreviousRevision(model, {
+      entryId,
+      version: version
+    });
+    if (!storageEntryToDelete) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${revisionId}" was not found!`);
+    }
+    await entriesPermissions.ensure({
+      owns: storageEntryToDelete.createdBy
+    });
+    const latestEntryRevisionId = latestStorageEntry ? latestStorageEntry.id : null;
+    const entryToDelete = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntryToDelete);
+    /**
+     * If targeted record is the latest entry record and there is no previous one, we need to run full delete with hooks.
+     * At this point deleteRevision hooks are not fired.
+     */
+    if (entryToDelete.id === latestEntryRevisionId && !previousStorageEntry) {
+      return await deleteEntryHelper({
+        model,
+        entry: entryToDelete
+      });
+    }
+    /**
+     * If targeted record is latest entry revision, set the previous one as the new latest
+     */
+    let entryToSetAsLatest = null;
+    let storageEntryToSetAsLatest = null;
+    if (entryToDelete.id === latestEntryRevisionId && previousStorageEntry) {
+      entryToSetAsLatest = await (0, _entryStorage.entryFromStorageTransform)(context, model, previousStorageEntry);
+      storageEntryToSetAsLatest = previousStorageEntry;
+    }
+    try {
+      await onEntryRevisionBeforeDelete.publish({
+        entry: entryToDelete,
+        model
+      });
+      await storageOperations.entries.deleteRevision(model, {
+        entry: entryToDelete,
+        storageEntry: storageEntryToDelete,
+        latestEntry: entryToSetAsLatest,
+        latestStorageEntry: storageEntryToSetAsLatest
+      });
+      await onEntryRevisionAfterDelete.publish({
+        entry: entryToDelete,
+        model
+      });
+    } catch (ex) {
+      await onEntryRevisionDeleteError.publish({
+        entry: entryToDelete,
+        model,
+        error: ex
+      });
+      throw new _error.default(ex.message, ex.code || "DELETE_REVISION_ERROR", {
+        error: ex,
+        entry: entryToDelete,
+        storageEntry: storageEntryToDelete,
+        latestEntry: entryToSetAsLatest,
+        latestStorageEntry: storageEntryToSetAsLatest
+      });
+    }
+  };
+  const deleteMultipleEntries = async (model, params) => {
+    const {
+      entries: input
+    } = params;
+    const maxDeletableEntries = 50;
+    const entryIdList = new Set();
+    for (const id of input) {
+      const {
+        id: entryId
+      } = (0, _utils.parseIdentifier)(id);
+      entryIdList.add(entryId);
+    }
+    const ids = Array.from(entryIdList);
+    if (ids.length > maxDeletableEntries) {
+      throw new _error.default("Cannot delete more than 50 entries at once.", "DELETE_ENTRIES_MAX", {
+        entries: ids
+      });
+    }
+    await entriesPermissions.ensure({
+      rwd: "d"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+    const {
+      items: entries
+    } = await storageOperations.entries.list(model, {
+      where: {
+        latest: true,
+        entryId_in: ids
+      },
+      limit: maxDeletableEntries + 1
+    });
+    /**
+     * We do not want to allow deleting entries that user does not own or cannot access.
+     */
+    const items = (await (0, _filterAsync.filterAsync)(entries, async entry => {
+      return entriesPermissions.ensure({
+        owns: entry.createdBy
+      }, {
+        throw: false
+      });
+    })).map(entry => entry.id);
+    try {
+      await onEntryBeforeDeleteMultiple.publish({
+        entries,
+        ids,
+        model
+      });
+      await storageOperations.entries.deleteMultipleEntries(model, {
+        entries: items
+      });
+      await onEntryAfterDeleteMultiple.publish({
+        entries,
+        ids,
+        model
+      });
+      return items.map(id => {
+        return {
+          id
+        };
+      });
+    } catch (ex) {
+      await onEntryDeleteMultipleError.publish({
+        entries,
+        ids,
+        model,
+        error: ex
+      });
+      throw new _error.default(ex.message, ex.code || "DELETE_ENTRIES_MULTIPLE_ERROR", {
+        error: ex,
+        entries
+      });
+    }
+  };
+  const deleteEntry = async (model, id, options) => {
+    await entriesPermissions.ensure({
+      rwd: "d"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+    const {
+      force
+    } = options || {};
+    const storageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+      id
+    });
+    /**
+     * If there is no entry, and we do not force the deletion, just throw an error.
+     */
+    if (!storageEntry && !force) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${id}" was not found!`);
+    }
+    /**
+     * In the case we are forcing the deletion, we do not need the storageEntry to exist as it might be an error when loading single database record.
+     *
+     * This happens, sometimes, in the Elasticsearch system as the entry might get deleted from the DynamoDB but not from the Elasticsearch.
+     * This is due to high load on the Elasticsearch at the time of the deletion.
+     */
+    //
+    else if (!storageEntry && force) {
+      const {
+        id: entryId
+      } = (0, _utils.parseIdentifier)(id);
+      return await deleteEntryHelper({
+        model,
+        entry: {
+          id,
+          entryId
+        }
+      });
+    }
+    await entriesPermissions.ensure({
+      owns: storageEntry.createdBy
+    });
+    const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntry);
+    return await deleteEntryHelper({
+      model,
+      entry
+    });
+  };
+  const publishEntry = async (model, id) => {
+    await entriesPermissions.ensure({
+      pw: "p"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+      id
+    });
+    if (!originalStorageEntry) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${id}" in the model "${model.modelId}" was not found.`);
+    }
+    await entriesPermissions.ensure({
+      owns: originalStorageEntry.createdBy
+    });
+    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    const currentDate = new Date().toISOString();
+    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+      status: STATUS_PUBLISHED,
+      locked: true,
+      savedOn: currentDate,
+      publishedOn: currentDate
+    });
+    let storageEntry = null;
+    try {
+      await onEntryBeforePublish.publish({
+        entry,
+        model
+      });
+      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+      const result = await storageOperations.entries.publish(model, {
+        entry,
+        storageEntry
+      });
+      await onEntryAfterPublish.publish({
+        entry,
+        storageEntry: result,
+        model
+      });
+      return result;
+    } catch (ex) {
+      await onEntryPublishError.publish({
+        entry,
+        model,
+        error: ex
+      });
+      throw new _error.default(ex.message || "Could not publish entry.", ex.code || "PUBLISH_ERROR", {
+        error: ex,
+        entry,
+        storageEntry,
+        originalEntry,
+        originalStorageEntry
+      });
+    }
+  };
+  const unpublishEntry = async (model, id) => {
+    await entriesPermissions.ensure({
+      pw: "u"
+    });
+    const {
+      id: entryId
+    } = (0, _utils.parseIdentifier)(id);
+    const originalStorageEntry = await storageOperations.entries.getPublishedRevisionByEntryId(model, {
+      id: entryId
+    });
+    if (!originalStorageEntry) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
+    }
+    if (originalStorageEntry.id !== id) {
+      throw new _error.default(`Entry is not published.`, "UNPUBLISH_ERROR", {
+        entry: originalStorageEntry
+      });
+    }
+    await entriesPermissions.ensure({
+      owns: originalStorageEntry.createdBy
+    });
+    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+      status: STATUS_UNPUBLISHED
+    });
+    let storageEntry = null;
+    try {
+      await onEntryBeforeUnpublish.publish({
+        entry,
+        model
+      });
+      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+      const result = await storageOperations.entries.unpublish(model, {
+        entry,
+        storageEntry
+      });
+      await onEntryAfterUnpublish.publish({
+        entry,
+        storageEntry: result,
+        model
+      });
+      return result;
+    } catch (ex) {
+      await onEntryUnpublishError.publish({
+        entry,
+        model,
+        error: ex
+      });
+      throw new _error.default(ex.message || "Could not unpublish entry.", ex.code || "UNPUBLISH_ERROR", {
+        originalEntry,
+        originalStorageEntry,
+        entry,
+        storageEntry
+      });
+    }
+  };
+  const getUniqueFieldValues = async (model, params) => {
+    await entriesPermissions.ensure({
+      rwd: "r"
+    });
+    await modelsPermissions.ensureCanAccessModel({
+      model,
+      locale: getLocale().code
+    });
+    const {
+      where: initialWhere,
+      fieldId
+    } = params;
+    const where = (0, _objectSpread2.default)({}, initialWhere);
+    /**
+     * Possibly only get records which are owned by current user.
+     * Or if searching for the owner set that value - in the case that user can see other entries than their own.
+     */
+    if (await entriesPermissions.canAccessOnlyOwnRecords()) {
+      where.ownedBy = getIdentity().id;
+    }
+
+    /**
+     * Where must contain either latest or published keys.
+     * We cannot list entries without one of those
+     */
+    if (where.latest && where.published) {
+      throw new _error.default("Cannot list entries that are both published and latest.", "LIST_ENTRIES_ERROR", {
+        where
+      });
+    } else if (!where.latest && !where.published) {
+      throw new _error.default("Cannot list entries if we do not have latest or published defined.", "LIST_ENTRIES_ERROR", {
+        where
+      });
+    }
+    /**
+     * We need to verify that the field in question is searchable.
+     */
+    const fields = (0, _searchableFields.getSearchableFields)({
+      fields: model.fields,
+      plugins: context.plugins,
+      input: []
+    });
+    if (!fields.includes(fieldId)) {
+      throw new _error.default("Cannot list unique entry field values if the field is not searchable.", "LIST_UNIQUE_ENTRY_VALUES_ERROR", {
+        fieldId
+      });
+    }
+    try {
+      return await storageOperations.entries.getUniqueFieldValues(model, {
+        where,
+        fieldId
+      });
+    } catch (ex) {
+      throw new _error.default("Error while fetching unique entry values from storage.", "LIST_UNIQUE_ENTRY_VALUES_ERROR", {
+        error: {
+          message: ex.message,
+          code: ex.code,
+          data: ex.data
+        },
+        model,
+        where,
+        fieldId
+      });
+    }
+  };
+  return {
+    /**
+     * Deprecated - will be removed in 5.35.0
+     */
+    onBeforeEntryCreate: onEntryBeforeCreate,
+    onAfterEntryCreate: onEntryAfterCreate,
+    onBeforeEntryCreateRevision: onEntryBeforeCreateRevision,
+    onAfterEntryCreateRevision: onEntryRevisionAfterCreate,
+    onBeforeEntryUpdate: onEntryBeforeUpdate,
+    onAfterEntryUpdate: onEntryAfterUpdate,
+    onBeforeEntryDelete: onEntryBeforeDelete,
+    onAfterEntryDelete: onEntryAfterDelete,
+    onBeforeEntryDeleteRevision: onEntryRevisionBeforeDelete,
+    onAfterEntryDeleteRevision: onEntryRevisionAfterDelete,
+    onBeforeEntryPublish: onEntryBeforePublish,
+    onAfterEntryPublish: onEntryAfterPublish,
+    onBeforeEntryUnpublish: onEntryBeforeUnpublish,
+    onAfterEntryUnpublish: onEntryAfterUnpublish,
+    onBeforeEntryGet: onEntryBeforeGet,
+    onBeforeEntryList: onEntryBeforeList,
+    /**
+     * Released in 5.34.0
+     *
+     * Create
+     */
+    onEntryBeforeCreate,
+    onEntryAfterCreate,
+    onEntryCreateError,
+    /**
+     * Create revision
+     */
+    onEntryRevisionBeforeCreate: onEntryBeforeCreateRevision,
+    onEntryRevisionAfterCreate,
+    onEntryRevisionCreateError: onEntryCreateRevisionError,
+    /**
+     * Update
+     */
+    onEntryBeforeUpdate,
+    onEntryAfterUpdate,
+    onEntryUpdateError,
+    /**
+     * Delete whole entry
+     */
+    onEntryBeforeDelete,
+    onEntryAfterDelete,
+    onEntryDeleteError,
+    /**
+     * Delete entry revision
+     */
+    onEntryRevisionBeforeDelete,
+    onEntryRevisionAfterDelete,
+    onEntryRevisionDeleteError,
+    /**
+     * Publish
+     */
+    onEntryBeforePublish,
+    onEntryAfterPublish,
+    onEntryPublishError,
+    /**
+     * Republish
+     */
+    onEntryBeforeRepublish,
+    onEntryAfterRepublish,
+    onEntryRepublishError,
+    /**
+     * Unpublish
+     */
+    onEntryBeforeUnpublish,
+    onEntryAfterUnpublish,
+    onEntryUnpublishError,
+    onEntryBeforeGet,
+    onEntryBeforeList,
+    /**
+     * Get entries by exact revision IDs from the database.
+     */
+    getEntriesByIds,
+    /**
+     * Get a single entry by revision ID from the database.
+     */
+    async getEntryById(model, id) {
+      return context.benchmark.measure("headlessCms.crud.entries.getEntryById", async () => {
+        return getEntryById(model, id);
+      });
+    },
+    /**
+     * Get published revisions by entry IDs.
+     */
+    async getPublishedEntriesByIds(model, ids) {
+      return context.benchmark.measure("headlessCms.crud.entries.getPublishedEntriesByIds", async () => {
+        return getPublishedEntriesByIds(model, ids);
+      });
+    },
+    /**
+     * Get the latest revisions by entry IDs.
+     */
+    async getLatestEntriesByIds(model, ids) {
+      return context.benchmark.measure("headlessCms.crud.entries.getLatestEntriesByIds", async () => {
+        return getLatestEntriesByIds(model, ids);
+      });
+    },
+    async getEntryRevisions(model, entryId) {
+      return context.benchmark.measure("headlessCms.crud.entries.getEntryRevisions", async () => {
+        return getEntryRevisions(model, entryId);
+      });
+    },
+    /**
+     * TODO determine if this method is required at all.
+     *
+     * @internal
+     */
+    async getEntry(model, params) {
+      return context.benchmark.measure("headlessCms.crud.entries.getEntry", async () => {
+        return getEntry(model, params);
+      });
+    },
+    /**
+     * @description Should not be used directly. Internal use only!
+     *
+     * @internal
+     */
+    async listEntries(model, params) {
+      return context.benchmark.measure("headlessCms.crud.entries.listEntries", async () => {
+        return listEntries(model, params);
       });
-      try {
-        await onEntryBeforeList.publish({
-          where,
-          model
-        });
-        const {
-          hasMoreItems,
-          totalCount,
-          cursor,
-          items
-        } = await storageOperations.entries.list(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-          where,
-          fields
-        }));
-        const meta = {
-          hasMoreItems,
-          totalCount,
-          /**
-           * Cursor should be null if there are no more items to load.
-           * Just make sure of that, disregarding what is returned from the storageOperations.entries.list method.
-           */
-          cursor: hasMoreItems ? cursor : null
-        };
-        return [items, meta];
-      } catch (ex) {
-        throw new _error.default("Error while fetching entries from storage.", "LIST_ENTRIES_ERROR", {
-          params,
-          error: {
-            message: ex.message,
-            code: ex.code,
-            data: ex.data
-          },
-          model,
-          fields
-        });
-      }
     },
     async listLatestEntries(model, params) {
       const where = (params === null || params === void 0 ? void 0 : params.where) || {};
@@ -565,572 +1418,59 @@ const createContentEntryCrud = params => {
         })
       }));
     },
-    async createEntry(initialModel, inputData) {
-      await checkEntryPermissions({
-        rwd: "w"
-      });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-
-      /**
-       * Make sure we only work with fields that are defined in the model.
-       */
-      const initialInput = mapAndCleanCreateInputData(model, inputData);
-      await (0, _entryDataValidation.validateModelEntryData)({
-        context,
-        model,
-        data: initialInput
-      });
-      const input = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-        context,
-        model,
-        input: initialInput,
-        validateEntries: true
+    async createEntry(model, input) {
+      return context.benchmark.measure("headlessCms.crud.entries.createEntry", async () => {
+        return createEntry(model, input);
       });
-      const identity = context.security.getIdentity();
-      const locale = this.getLocale();
-      const owner = {
-        id: identity.id,
-        displayName: identity.displayName,
-        type: identity.type
-      };
-      const {
-        id,
-        entryId,
-        version
-      } = createEntryId(1);
-      const entry = {
-        webinyVersion: context.WEBINY_VERSION,
-        tenant: getTenant().id,
-        entryId,
-        id,
-        modelId: model.modelId,
-        locale: locale.code,
-        createdOn: new Date().toISOString(),
-        savedOn: new Date().toISOString(),
-        createdBy: owner,
-        ownedBy: owner,
-        version,
-        locked: false,
-        status: STATUS_DRAFT,
-        values: input
-      };
-      let storageEntry = null;
-      try {
-        await onEntryBeforeCreate.publish({
-          entry,
-          input,
-          model
-        });
-        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-        const result = await storageOperations.entries.create(model, {
-          entry,
-          storageEntry
-        });
-        await onEntryAfterCreate.publish({
-          entry,
-          storageEntry: result,
-          model,
-          input
-        });
-        return result;
-      } catch (ex) {
-        await onEntryCreateError.publish({
-          error: ex,
-          entry,
-          model,
-          input
-        });
-        throw new _error.default(ex.message || "Could not create content entry.", ex.code || "CREATE_ENTRY_ERROR", ex.data || {
-          error: ex,
-          input,
-          entry,
-          storageEntry
-        });
-      }
     },
-    async createEntryRevisionFrom(initialModel, sourceId, inputData) {
-      const permission = await checkEntryPermissions({
-        rwd: "w"
-      });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-
-      /**
-       * Make sure we only work with fields that are defined in the model.
-       */
-      const input = mapAndCleanUpdatedInputData(model, inputData);
-
-      /**
-       * Entries are identified by a common parent ID + Revision number.
-       */
-      const {
-        id: uniqueId
-      } = (0, _utils.parseIdentifier)(sourceId);
-      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        id: sourceId
-      });
-      const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-        id: uniqueId
-      });
-      if (!originalStorageEntry) {
-        throw new _handlerGraphql.NotFoundError(`Entry "${sourceId}" of model "${model.modelId}" was not found.`);
-      }
-
-      /**
-       * We need to convert data from DB to its original form before using it further.
-       */
-      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-      const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
-      await (0, _entryDataValidation.validateModelEntryData)({
-        context,
-        model,
-        data: initialValues,
-        entry: originalEntry
-      });
-      const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-        context,
-        model,
-        input: initialValues,
-        validateEntries: false
-      });
-      (0, _ownership.checkOwnership)(context, permission, originalEntry);
-      const identity = context.security.getIdentity();
-      const latestId = latestStorageEntry ? latestStorageEntry.id : sourceId;
-      const {
-        id,
-        version: nextVersion
-      } = increaseEntryIdVersion(latestId);
-      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-        id,
-        version: nextVersion,
-        savedOn: new Date().toISOString(),
-        createdOn: new Date().toISOString(),
-        createdBy: {
-          id: identity.id,
-          displayName: identity.displayName,
-          type: identity.type
-        },
-        locked: false,
-        publishedOn: undefined,
-        status: STATUS_DRAFT,
-        values
+    async createEntryRevisionFrom(model, sourceId, input) {
+      return context.benchmark.measure("headlessCms.crud.entries.createEntryRevisionFrom", async () => {
+        return createEntryRevisionFrom(model, sourceId, input);
       });
-      let storageEntry = null;
-      try {
-        await onEntryBeforeCreateRevision.publish({
-          input,
-          entry,
-          original: originalEntry,
-          model
-        });
-        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-        const result = await storageOperations.entries.createRevisionFrom(model, {
-          entry,
-          storageEntry
-        });
-        await onEntryRevisionAfterCreate.publish({
-          input,
-          entry,
-          model,
-          original: originalEntry,
-          storageEntry: result
-        });
-        return result;
-      } catch (ex) {
-        await onEntryCreateRevisionError.publish({
-          entry,
-          model,
-          input,
-          error: ex
-        });
-        throw new _error.default(ex.message || "Could not create entry from existing one.", ex.code || "CREATE_FROM_REVISION_ERROR", {
-          error: ex,
-          entry,
-          storageEntry,
-          originalEntry,
-          originalStorageEntry
-        });
-      }
     },
-    async updateEntry(initialModel, id, inputData, metaInput) {
-      const permission = await checkEntryPermissions({
-        rwd: "w"
-      });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-
-      /**
-       * Make sure we only work with fields that are defined in the model.
-       */
-      const input = mapAndCleanUpdatedInputData(model, inputData);
-
-      /**
-       * The entry we are going to update.
-       */
-      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        id
-      });
-      if (!originalStorageEntry) {
-        throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
-      }
-      if (originalStorageEntry.locked) {
-        throw new _error.default(`Cannot update entry because it's locked.`, "CONTENT_ENTRY_UPDATE_ERROR");
-      }
-      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-      await (0, _entryDataValidation.validateModelEntryData)({
-        context,
-        model,
-        data: input,
-        entry: originalEntry
+    async updateEntry(model, id, input, meta) {
+      return context.benchmark.measure("headlessCms.crud.entries.updateEntry", async () => {
+        return updateEntry(model, id, input, meta);
       });
-      (0, _ownership.checkOwnership)(context, permission, originalEntry);
-      const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
-      const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-        context,
-        model,
-        input: initialValues,
-        validateEntries: false
-      });
-      /**
-       * If users wants to remove a key from meta values, they need to send meta key with the null value.
-       */
-      const meta = createEntryMeta(metaInput, originalEntry.meta);
-      /**
-       * We always send the full entry to the hooks and storage operations update.
-       */
-      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-        savedOn: new Date().toISOString(),
-        values,
-        meta,
-        status: transformEntryStatus(originalEntry.status)
-      });
-      let storageEntry = null;
-      try {
-        await onEntryBeforeUpdate.publish({
-          entry,
-          model,
-          input,
-          original: originalEntry
-        });
-        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-        const result = await storageOperations.entries.update(model, {
-          entry,
-          storageEntry
-        });
-        await onEntryAfterUpdate.publish({
-          entry,
-          storageEntry: result,
-          model,
-          input,
-          original: originalEntry
-        });
-        return result;
-      } catch (ex) {
-        await onEntryUpdateError.publish({
-          entry,
-          model,
-          input,
-          error: ex
-        });
-        throw new _error.default(ex.message || "Could not update existing entry.", ex.code || "UPDATE_ERROR", {
-          error: ex,
-          entry,
-          storageEntry,
-          originalEntry,
-          input
-        });
-      }
-    },
-    async republishEntry(initialModel, id) {
-      await checkEntryPermissions({
-        rwd: "w"
-      });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-      /**
-       * Fetch the entry from the storage.
-       */
-      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        id
-      });
-      if (!originalStorageEntry) {
-        throw new _handlerGraphql.NotFoundError(`Entry "${id}" was not found!`);
-      }
-      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-      /**
-       * We can only process published entries.
-       */
-      if (originalEntry.status !== "published") {
-        throw new _error.default("Entry with given ID is not published!", "NOT_PUBLISHED_ERROR", {
-          id,
-          original: originalEntry
-        });
-      }
-      const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-        context,
-        model,
-        input: originalEntry.values,
-        validateEntries: false
-      });
-      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-        savedOn: new Date().toISOString(),
-        webinyVersion: context.WEBINY_VERSION,
-        values
-      });
-      const storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-      /**
-       * First we need to update existing entry.
-       */
-      try {
-        await storageOperations.entries.update(model, {
-          entry,
-          storageEntry
-        });
-      } catch (ex) {
-        throw new _error.default("Could not update existing entry with new data while re-publishing.", "REPUBLISH_UPDATE_ERROR", {
-          entry
-        });
-      }
-      /**
-       * Then we move onto publishing it again.
-       */
-      try {
-        return await storageOperations.entries.publish(model, {
-          entry,
-          storageEntry
-        });
-      } catch (ex) {
-        throw new _error.default("Could not publish existing entry while re-publishing.", "REPUBLISH_PUBLISH_ERROR", {
-          entry
-        });
-      }
     },
-    async deleteEntryRevision(initialModel, revisionId) {
-      const permission = await checkEntryPermissions({
-        rwd: "d"
-      });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-      const {
-        id: entryId,
-        version
-      } = (0, _utils.parseIdentifier)(revisionId);
-      const storageEntryToDelete = await storageOperations.entries.getRevisionById(model, {
-        id: revisionId
-      });
-      const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-        id: entryId
-      });
-      const previousStorageEntry = await storageOperations.entries.getPreviousRevision(model, {
-        entryId,
-        version: version
+    /**
+     * Method used internally. Not documented and should not be used in users systems.
+     * @internal
+     */
+    async republishEntry(model, id) {
+      return context.benchmark.measure("headlessCms.crud.entries.republishEntry", async () => {
+        return republishEntry(model, id);
       });
-      if (!storageEntryToDelete) {
-        throw new _handlerGraphql.NotFoundError(`Entry "${revisionId}" was not found!`);
-      }
-      (0, _ownership.checkOwnership)(context, permission, storageEntryToDelete);
-      const latestEntryRevisionId = latestStorageEntry ? latestStorageEntry.id : null;
-      const entryToDelete = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntryToDelete);
-      /**
-       * If targeted record is the latest entry record and there is no previous one, we need to run full delete with hooks.
-       * At this point deleteRevision hooks are not fired.
-       */
-      if (entryToDelete.id === latestEntryRevisionId && !previousStorageEntry) {
-        return await deleteEntry({
-          model,
-          entry: entryToDelete
-        });
-      }
-      /**
-       * If targeted record is latest entry revision, set the previous one as the new latest
-       */
-      let entryToSetAsLatest = null;
-      let storageEntryToSetAsLatest = null;
-      if (entryToDelete.id === latestEntryRevisionId && previousStorageEntry) {
-        entryToSetAsLatest = await (0, _entryStorage.entryFromStorageTransform)(context, model, previousStorageEntry);
-        storageEntryToSetAsLatest = previousStorageEntry;
-      }
-      try {
-        await onEntryRevisionBeforeDelete.publish({
-          entry: entryToDelete,
-          model
-        });
-        await storageOperations.entries.deleteRevision(model, {
-          entry: entryToDelete,
-          storageEntry: storageEntryToDelete,
-          latestEntry: entryToSetAsLatest,
-          latestStorageEntry: storageEntryToSetAsLatest
-        });
-        await onEntryRevisionAfterDelete.publish({
-          entry: entryToDelete,
-          model
-        });
-      } catch (ex) {
-        await onEntryRevisionDeleteError.publish({
-          entry: entryToDelete,
-          model,
-          error: ex
-        });
-        throw new _error.default(ex.message, ex.code || "DELETE_REVISION_ERROR", {
-          error: ex,
-          entry: entryToDelete,
-          storageEntry: storageEntryToDelete,
-          latestEntry: entryToSetAsLatest,
-          latestStorageEntry: storageEntryToSetAsLatest
-        });
-      }
     },
-    async deleteEntry(initialModel, entryId) {
-      const permission = await checkEntryPermissions({
-        rwd: "d"
-      });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
-      });
-      const storageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-        id: entryId
-      });
-      if (!storageEntry) {
-        throw new _handlerGraphql.NotFoundError(`Entry "${entryId}" was not found!`);
-      }
-      (0, _ownership.checkOwnership)(context, permission, storageEntry);
-      const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntry);
-      return await deleteEntry({
-        model,
-        entry
+    async deleteEntryRevision(model, id) {
+      return context.benchmark.measure("headlessCms.crud.entries.deleteEntryRevision", async () => {
+        return deleteEntryRevision(model, id);
       });
     },
-    async publishEntry(initialModel, id) {
-      const permission = await checkEntryPermissions({
-        pw: "p"
-      });
-      await (0, _access.checkModelAccess)(context, initialModel);
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
+    async deleteEntry(model, entryId, options) {
+      return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async () => {
+        return deleteEntry(model, entryId, options);
       });
-      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-        id
-      });
-      if (!originalStorageEntry) {
-        throw new _handlerGraphql.NotFoundError(`Entry "${id}" in the model "${model.modelId}" was not found.`);
-      }
-      (0, _ownership.checkOwnership)(context, permission, originalStorageEntry);
-      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-      const currentDate = new Date().toISOString();
-      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-        status: STATUS_PUBLISHED,
-        locked: true,
-        savedOn: currentDate,
-        publishedOn: currentDate
-      });
-      let storageEntry = null;
-      try {
-        await onEntryBeforePublish.publish({
-          entry,
-          model
-        });
-        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-        const result = await storageOperations.entries.publish(model, {
-          entry,
-          storageEntry
-        });
-        await onEntryAfterPublish.publish({
-          entry,
-          storageEntry: result,
-          model
-        });
-        return result;
-      } catch (ex) {
-        await onEntryPublishError.publish({
-          entry,
-          model,
-          error: ex
-        });
-        throw new _error.default(ex.message || "Could not publish entry.", ex.code || "PUBLISH_ERROR", {
-          error: ex,
-          entry,
-          storageEntry,
-          originalEntry,
-          originalStorageEntry
-        });
-      }
     },
-    async unpublishEntry(initialModel, id) {
-      const permission = await checkEntryPermissions({
-        pw: "u"
+    async deleteMultipleEntries(model, ids) {
+      return context.benchmark.measure("headlessCms.crud.entries.deleteMultipleEntries", async () => {
+        return deleteMultipleEntries(model, ids);
       });
-      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-        model: initialModel,
-        plugins
+    },
+    async publishEntry(model, id) {
+      return context.benchmark.measure("headlessCms.crud.entries.publishEntry", async () => {
+        return publishEntry(model, id);
       });
-      const {
-        id: entryId
-      } = (0, _utils.parseIdentifier)(id);
-      const originalStorageEntry = await storageOperations.entries.getPublishedRevisionByEntryId(model, {
-        id: entryId
+    },
+    async unpublishEntry(model, id) {
+      return context.benchmark.measure("headlessCms.crud.entries.unpublishEntry", async () => {
+        return unpublishEntry(model, id);
       });
-      if (!originalStorageEntry) {
-        throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
-      }
-      if (originalStorageEntry.id !== id) {
-        throw new _error.default(`Entry is not published.`, "UNPUBLISH_ERROR", {
-          entry: originalStorageEntry
-        });
-      }
-      (0, _ownership.checkOwnership)(context, permission, originalStorageEntry);
-      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-        status: STATUS_UNPUBLISHED
+    },
+    async getUniqueFieldValues(model, params) {
+      return context.benchmark.measure("headlessCms.crud.entries.getUniqueFieldValues", async () => {
+        return getUniqueFieldValues(model, params);
       });
-      let storageEntry = null;
-      try {
-        await onEntryBeforeUnpublish.publish({
-          entry,
-          model
-        });
-        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-        const result = await storageOperations.entries.unpublish(model, {
-          entry,
-          storageEntry
-        });
-        await onEntryAfterUnpublish.publish({
-          entry,
-          storageEntry: result,
-          model
-        });
-        return result;
-      } catch (ex) {
-        await onEntryUnpublishError.publish({
-          entry,
-          model,
-          error: ex
-        });
-        throw new _error.default(ex.message || "Could not unpublish entry.", ex.code || "UNPUBLISH_ERROR", {
-          originalEntry,
-          originalStorageEntry,
-          entry,
-          storageEntry
-        });
-      }
     }
   };
 };