@webiny/api-headless-cms 0.0.0-unstable.9e825fd5fb → 0.0.0-unstable.a4637c5ce6

package/crud/contentEntry.crud.js

@@ -4,197 +4,31 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createContentEntryCrud = exports.STATUS_UNPUBLISHED = exports.STATUS_PUBLISHED = exports.STATUS_DRAFT = void 0;
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-var _merge = _interopRequireDefault(require("lodash/merge"));
-var _mdbid = _interopRequireDefault(require("mdbid"));
+exports.createContentEntryCrud = void 0;
+var _utils = require("@webiny/utils");
 var _error = _interopRequireDefault(require("@webiny/error"));
 var _handlerGraphql = require("@webiny/handler-graphql");
 var _entryDataValidation = require("./contentEntry/entryDataValidation");
 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 _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");
 var _searchableFields = require("./contentEntry/searchableFields");
-/**
- * Package mdbid does not have types.
- */
-// @ts-ignore
-
-const STATUS_DRAFT = "draft";
-exports.STATUS_DRAFT = STATUS_DRAFT;
-const STATUS_PUBLISHED = "published";
-exports.STATUS_PUBLISHED = STATUS_PUBLISHED;
-const STATUS_UNPUBLISHED = "unpublished";
-exports.STATUS_UNPUBLISHED = STATUS_UNPUBLISHED;
-/**
- * Used for some fields to convert their values.
- */
-const convertDefaultValue = (field, value) => {
-  switch (field.type) {
-    case "boolean":
-      return Boolean(value);
-    case "number":
-      return Number(value);
-    default:
-      return value;
-  }
-};
-const getDefaultValue = field => {
-  const {
-    settings,
-    multipleValues
-  } = field;
-  if (settings && settings.defaultValue !== undefined) {
-    return convertDefaultValue(field, settings.defaultValue);
-  }
-  const {
-    predefinedValues
-  } = field;
-  if (!predefinedValues || !predefinedValues.enabled || Array.isArray(predefinedValues.values) === false) {
-    return undefined;
-  }
-  if (!multipleValues) {
-    const selectedValue = predefinedValues.values.find(value => {
-      return !!value.selected;
-    });
-    if (selectedValue) {
-      return convertDefaultValue(field, selectedValue.value);
-    }
-    return undefined;
-  }
-  return predefinedValues.values.filter(({
-    selected
-  }) => !!selected).map(({
-    value
-  }) => {
-    return convertDefaultValue(field, value);
-  });
-};
-/**
- * Cleans and adds default values to create input data.
- */
-const mapAndCleanCreateInputData = (model, input) => {
-  return model.fields.reduce((acc, field) => {
-    /**
-     * This should never happen, but let's make it sure.
-     * The fix would be for the user to add the fieldId on the field definition.
-     */
-    if (!field.fieldId) {
-      throw new _error.default("Field does not have an fieldId.", "MISSING_FIELD_ID", {
-        field
-      });
-    }
-    const value = input[field.fieldId];
-    /**
-     * We set the default value on create input if value is not defined.
-     */
-    acc[field.fieldId] = value === undefined ? getDefaultValue(field) : value;
-    return acc;
-  }, {});
-};
-/**
- * Cleans the update input entry data.
- */
-const mapAndCleanUpdatedInputData = (model, input) => {
-  return model.fields.reduce((acc, field) => {
-    /**
-     * This should never happen, but let's make it sure.
-     * The fix would be for the user to add the fieldId on the field definition.
-     */
-    if (!field.fieldId) {
-      throw new _error.default("Field does not have an fieldId.", "MISSING_FIELD_ID", {
-        field
-      });
-    }
-    /**
-     * We cannot set default value here because user might want to update only certain field values.
-     */
-    const value = input[field.fieldId];
-    if (value === undefined) {
-      return acc;
-    }
-    acc[field.fieldId] = value;
-    return acc;
-  }, {});
-};
-/**
- * This method takes original entry meta and new input.
- * When new meta is merged onto the existing one, everything that has undefined or null value is removed.
- */
-const createEntryMeta = (input, original) => {
-  const meta = (0, _merge.default)(original || {}, input || {});
-  return (0, _utils.removeUndefinedValues)((0, _utils.removeNullValues)(meta));
-};
-const createEntryId = input => {
-  let entryId = (0, _mdbid.default)();
-  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
-      });
-    }
-    entryId = input.id;
-  }
-  const version = 1;
-  return {
-    entryId,
-    version,
-    id: (0, _utils.createIdentifier)({
-      id: entryId,
-      version
-    })
-  };
-};
-const increaseEntryIdVersion = id => {
-  const {
-    id: entryId,
-    version
-  } = (0, _utils.parseIdentifier)(id);
-  if (!version) {
-    throw new _error.default("Cannot increase version on the ID without the version part.", "WRONG_ID", {
-      id
-    });
-  }
-  return {
-    entryId,
-    version: version + 1,
-    id: (0, _utils.createIdentifier)({
-      id: entryId,
-      version: version + 1
-    })
-  };
-};
-const allowedEntryStatus = ["draft", "published", "unpublished"];
-const transformEntryStatus = status => {
-  return allowedEntryStatus.includes(status) ? status : "draft";
-};
+var _filterAsync = require("../utils/filterAsync");
+var _constants = require("../constants");
+var _entryDataFactories = require("./contentEntry/entryDataFactories");
+var _useCases = require("./contentEntry/useCases");
+var _ContentEntryTraverser = require("../utils/contentEntryTraverser/ContentEntryTraverser");
 const createContentEntryCrud = params => {
   const {
     storageOperations,
+    accessControl,
     context,
-    getIdentity,
+    getIdentity: getSecurityIdentity,
     getTenant,
     getLocale
   } = params;
-  const {
-    plugins
-  } = context;
-  const getCreatedBy = () => {
-    const identity = getIdentity();
-    return {
-      id: identity.id,
-      displayName: identity.displayName,
-      type: identity.type
-    };
-  };
 
   /**
    * Create
@@ -217,6 +51,13 @@ const createContentEntryCrud = params => {
   const onEntryAfterUpdate = (0, _pubsub.createTopic)("cms.onEntryAfterUpdate");
   const onEntryUpdateError = (0, _pubsub.createTopic)("cms.onEntryUpdateError");
 
+  /**
+   * Move
+   */
+  const onEntryBeforeMove = (0, _pubsub.createTopic)("cms.onEntryBeforeMove");
+  const onEntryAfterMove = (0, _pubsub.createTopic)("cms.onEntryAfterMove");
+  const onEntryMoveError = (0, _pubsub.createTopic)("cms.onEntryMoveError");
+
   /**
    * Publish
    */
@@ -245,12 +86,25 @@ const createContentEntryCrud = params => {
   const onEntryAfterDelete = (0, _pubsub.createTopic)("cms.onEntryAfterDelete");
   const onEntryDeleteError = (0, _pubsub.createTopic)("cms.onEntryDeleteError");
 
+  /**
+   * Restore from bin
+   */
+  const onEntryBeforeRestoreFromBin = (0, _pubsub.createTopic)("cms.onEntryBeforeRestoreFromBin");
+  const onEntryAfterRestoreFromBin = (0, _pubsub.createTopic)("cms.onEntryAfterRestoreFromBin");
+  const onEntryRestoreFromBinError = (0, _pubsub.createTopic)("cms.onEntryRestoreFromBinError");
+
   /**
    * 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 entry
@@ -277,279 +131,195 @@ const createContentEntryCrud = params => {
     context,
     onEntryAfterDelete
   });
-  const checkEntryPermissions = check => {
-    return (0, _permissions.checkPermissions)(context, "cms.contentEntry", check);
-  };
+  const transformEntryFromStorageCallable = (0, _entryStorage.createTransformEntryCallable)({
+    context
+  });
+  /**
+   * List entries
+   */
+  const {
+    listEntriesUseCase,
+    listLatestUseCase,
+    listDeletedUseCase,
+    listPublishedUseCase,
+    getEntryUseCase
+  } = (0, _useCases.listEntriesUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.list,
+    accessControl,
+    topics: {
+      onEntryBeforeList
+    },
+    context,
+    getIdentity: getSecurityIdentity
+  });
 
   /**
-   * A helper to delete the entire entry.
+   * Get entries by ids
    */
-  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
-        });
-      }
-    });
-  };
+  const {
+    getEntriesByIdsUseCase
+  } = (0, _useCases.getEntriesByIdsUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.getByIds,
+    accessControl
+  });
+
   /**
-   * A helper to get entries by revision IDs
+   * Get latest entries by ids
    */
-  const getEntriesByIds = async (initialModel, ids) => {
-    return context.benchmark.measure("headlessCms.crud.entries.getEntriesByIds", async () => {
-      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.getByIds(model, {
-        ids
-      });
-      return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
-    });
-  };
-  const getEntryById = async (initialModel, id) => {
+  const {
+    getLatestEntriesByIdsUseCase
+  } = (0, _useCases.getLatestEntriesByIdsUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.getLatestByIds,
+    accessControl
+  });
+
+  /**
+   * Get published entries by ids
+   */
+  const {
+    getPublishedEntriesByIdsUseCase
+  } = (0, _useCases.getPublishedEntriesByIdsUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.getPublishedByIds,
+    accessControl
+  });
+
+  /**
+   * Get revisions by entryId
+   */
+  const {
+    getRevisionsByEntryIdUseCase
+  } = (0, _useCases.getRevisionsByEntryIdUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.getRevisions,
+    accessControl
+  });
+
+  /**
+   * Get revision by id
+   */
+  const {
+    getRevisionByIdUseCase
+  } = (0, _useCases.getRevisionByIdUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.getRevisionById
+  });
+
+  /**
+   * Get latest revision by entryId
+   */
+  const {
+    getLatestRevisionByEntryIdUseCase,
+    getLatestRevisionByEntryIdWithDeletedUseCase,
+    getLatestRevisionByEntryIdDeletedUseCase
+  } = (0, _useCases.getLatestRevisionByEntryIdUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.getLatestRevisionByEntryId
+  });
+
+  /**
+   * Get previous revision by entryId
+   */
+  const {
+    getPreviousRevisionByEntryIdUseCase
+  } = (0, _useCases.getPreviousRevisionByEntryIdUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.getPreviousRevision
+  });
+
+  /**
+   * Get published revision by entryId
+   */
+  const {
+    getPublishedRevisionByEntryIdUseCase
+  } = (0, _useCases.getPublishedRevisionByEntryIdUseCases)({
+    transform: transformEntryFromStorageCallable,
+    operation: storageOperations.entries.getPublishedRevisionByEntryId
+  });
+
+  /**
+   * Delete entry
+   */
+  const {
+    deleteEntryUseCase,
+    moveEntryToBinUseCase,
+    deleteEntryOperation
+  } = (0, _useCases.deleteEntryUseCases)({
+    deleteOperation: storageOperations.entries.delete,
+    moveToBinOperation: storageOperations.entries.moveToBin,
+    getEntry: getLatestRevisionByEntryIdUseCase,
+    getEntryWithDeleted: getLatestRevisionByEntryIdWithDeletedUseCase,
+    getIdentity: getSecurityIdentity,
+    topics: {
+      onEntryBeforeDelete,
+      onEntryAfterDelete,
+      onEntryDeleteError
+    },
+    accessControl,
+    context
+  });
+
+  /**
+   * Restore entry from bin
+   */
+  const {
+    restoreEntryFromBinUseCase
+  } = (0, _useCases.restoreEntryFromBinUseCases)({
+    transform: transformEntryFromStorageCallable,
+    getEntry: getLatestRevisionByEntryIdDeletedUseCase,
+    getIdentity: getSecurityIdentity,
+    restoreOperation: storageOperations.entries.restoreFromBin,
+    topics: {
+      onEntryBeforeRestoreFromBin,
+      onEntryAfterRestoreFromBin,
+      onEntryRestoreFromBinError
+    },
+    accessControl,
+    context
+  });
+  const getEntryById = async (model, id) => {
     const where = {
       id
     };
-    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-      model: initialModel,
-      plugins
-    });
     await onEntryBeforeGet.publish({
       where,
       model
     });
-    const [entry] = await getEntriesByIds(model, [id]);
+    const [entry] = await getEntriesByIdsUseCase.execute(model, {
+      ids: [id]
+    });
     if (!entry) {
       throw new _handlerGraphql.NotFoundError(`Entry by ID "${id}" not found.`);
     }
+    // TODO figure out without casting
     return entry;
   };
-  const getPublishedEntriesByIds = async (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.getPublishedByIds(model, {
-      ids
-    });
-    return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
-  };
-  const getLatestEntriesByIds = async (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));
-  };
-  const getEntry = async (initialModel, params) => {
-    await checkEntryPermissions({
-      rwd: "r"
-    });
-    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-      model: initialModel,
-      plugins
-    });
-    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 (initialModel, entryId) => {
-    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-      model: initialModel,
-      plugins
-    });
-    return storageOperations.entries.getRevisions(model, {
-      id: entryId
-    });
-  };
-  const listEntries = async (initialModel, params) => {
-    const permission = await checkEntryPermissions({
-      rwd: "r"
-    });
-    await (0, _access.checkModelAccess)(context, initialModel);
-    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-      model: initialModel,
-      plugins
-    });
-    const {
-      where: initialWhere,
-      limit: initialLimit
-    } = params;
-    const limit = initialLimit && initialLimit > 0 ? initialLimit : 50;
-    /**
-     * 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 = (0, _searchableFields.getSearchableFields)({
-      fields: model.fields,
-      plugins: context.plugins,
-      input: params.fields || []
-    });
-    try {
-      await onEntryBeforeList.publish({
-        where,
-        model
-      });
-      const {
-        hasMoreItems,
-        totalCount,
-        cursor,
-        items
-      } = await storageOperations.entries.list(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-        limit,
-        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
-      });
-    }
-  };
-  const createEntry = async (initialModel, inputData) => {
-    await checkEntryPermissions({
+  const createEntry = async (model, rawInput, options) => {
+    await accessControl.ensureCanAccessEntry({
+      model,
       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)({
+    const {
+      entry,
+      input
+    } = await (0, _entryDataFactories.createEntryData)({
       context,
       model,
-      data: initialInput
+      options,
+      rawInput,
+      getLocale,
+      getTenant,
+      getIdentity: getSecurityIdentity,
+      accessControl
     });
-    const input = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-      context,
+    await accessControl.ensureCanAccessEntry({
       model,
-      input: initialInput,
-      validateEntries: true
+      entry,
+      rwd: "w"
     });
-    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
-    };
     let storageEntry = null;
     try {
       await onEntryBeforeCreate.publish({
@@ -568,7 +338,7 @@ const createContentEntryCrud = params => {
         model,
         input
       });
-      return result;
+      return entry;
     } catch (ex) {
       await onEntryCreateError.publish({
         error: ex,
@@ -584,20 +354,11 @@ const createContentEntryCrud = params => {
       });
     }
   };
-  const createEntryRevisionFrom = async (initialModel, sourceId, inputData) => {
-    const permission = await checkEntryPermissions({
+  const createEntryRevisionFrom = async (model, sourceId, rawInput, options) => {
+    await accessControl.ensureCanAccessEntry({
+      model,
       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.
@@ -605,55 +366,43 @@ const createContentEntryCrud = params => {
     const {
       id: uniqueId
     } = (0, _utils.parseIdentifier)(sourceId);
-    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+    const originalStorageEntry = await getRevisionByIdUseCase.execute(model, {
       id: sourceId
     });
-    const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+    const latestStorageEntry = await getLatestRevisionByEntryIdUseCase.execute(model, {
       id: uniqueId
     });
     if (!originalStorageEntry) {
       throw new _handlerGraphql.NotFoundError(`Entry "${sourceId}" of model "${model.modelId}" was not found.`);
     }
+    if (!latestStorageEntry) {
+      throw new _handlerGraphql.NotFoundError(`Latest entry "${uniqueId}" 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,
+    const {
+      entry,
+      input
+    } = await (0, _entryDataFactories.createEntryRevisionFromData)({
+      sourceId,
       model,
-      data: initialValues,
-      entry: originalEntry
-    });
-    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+      rawInput,
+      options,
       context,
-      model,
-      input: initialValues,
-      validateEntries: false
+      getIdentity: getSecurityIdentity,
+      getTenant,
+      getLocale,
+      originalEntry,
+      latestStorageEntry,
+      accessControl
     });
-    (0, _ownership.checkOwnership)(context, permission, originalEntry);
-    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
+    await accessControl.ensureCanAccessEntry({
+      model,
+      entry,
+      rwd: "w"
     });
     let storageEntry = null;
     try {
@@ -675,7 +424,7 @@ const createContentEntryCrud = params => {
         original: originalEntry,
         storageEntry: result
       });
-      return result;
+      return entry;
     } catch (ex) {
       await onEntryCreateRevisionError.publish({
         entry,
@@ -693,25 +442,16 @@ const createContentEntryCrud = params => {
       });
     }
   };
-  const updateEntry = async (initialModel, id, inputData, metaInput) => {
-    const permission = await checkEntryPermissions({
+  const updateEntry = async (model, id, rawInput, metaInput, options) => {
+    await accessControl.ensureCanAccessEntry({
+      model,
       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, {
+    const originalStorageEntry = await getRevisionByIdUseCase.execute(model, {
       id
     });
     if (!originalStorageEntry) {
@@ -721,33 +461,24 @@ const createContentEntryCrud = params => {
       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,
+    const {
+      entry,
+      input
+    } = await (0, _entryDataFactories.createUpdateEntryData)({
       model,
-      data: input,
-      entry: originalEntry
-    });
-    (0, _ownership.checkOwnership)(context, permission, originalEntry);
-    const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
-    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+      rawInput,
+      options,
       context,
-      model,
-      input: initialValues,
-      validateEntries: false
+      getIdentity: getSecurityIdentity,
+      getTenant,
+      getLocale,
+      originalEntry,
+      metaInput
     });
-    /**
-     * 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)
+    await accessControl.ensureCanAccessEntry({
+      model,
+      entry,
+      rwd: "w"
     });
     let storageEntry = null;
     try {
@@ -769,7 +500,7 @@ const createContentEntryCrud = params => {
         input,
         original: originalEntry
       });
-      return result;
+      return entry;
     } catch (ex) {
       await onEntryUpdateError.publish({
         entry,
@@ -786,44 +517,122 @@ const createContentEntryCrud = params => {
       });
     }
   };
-  const republishEntry = async (initialModel, id) => {
-    await checkEntryPermissions({
+  const validateEntry = async (model, id, inputData) => {
+    await accessControl.ensureCanAccessEntry({
+      model,
       rwd: "w"
     });
-    await (0, _access.checkModelAccess)(context, initialModel);
-    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-      model: initialModel,
-      plugins
+    const input = (0, _entryDataFactories.mapAndCleanUpdatedInputData)(model, inputData || {});
+    let originalEntry;
+    if (id) {
+      /**
+       * The entry we are going to update.
+       */
+      const originalStorageEntry = await getRevisionByIdUseCase.execute(model, {
+        id
+      });
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
+      }
+      originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    }
+    await accessControl.ensureCanAccessEntry({
+      model,
+      entry: originalEntry,
+      rwd: "w"
+    });
+    const result = await (0, _entryDataValidation.validateModelEntryData)({
+      context,
+      model,
+      data: input,
+      entry: originalEntry
     });
+    return result.length > 0 ? result : [];
+  };
+  const moveEntry = async (model, id, folderId) => {
+    await accessControl.ensureCanAccessEntry({
+      model,
+      rwd: "w"
+    });
+
     /**
-     * Fetch the entry from the storage.
+     * The entry we are going to move to another folder.
      */
-    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+    const originalStorageEntry = await getRevisionByIdUseCase.execute(model, {
       id
     });
     if (!originalStorageEntry) {
-      throw new _handlerGraphql.NotFoundError(`Entry "${id}" was not found!`);
+      throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
     }
-    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    await accessControl.ensureCanAccessEntry({
+      model,
+      entry,
+      rwd: "w"
+    });
+
     /**
-     * We can only process published entries.
+     * No need to continue if the entry is already in the requested folder.
      */
-    if (originalEntry.status !== "published") {
-      throw new _error.default("Entry with given ID is not published!", "NOT_PUBLISHED_ERROR", {
-        id,
-        original: originalEntry
+    if (entry.location?.folderId === folderId) {
+      return entry;
+    }
+    try {
+      await onEntryBeforeMove.publish({
+        entry,
+        model,
+        folderId
+      });
+      await storageOperations.entries.move(model, id, folderId);
+      await onEntryAfterMove.publish({
+        entry,
+        model,
+        folderId
+      });
+      return entry;
+    } catch (ex) {
+      await onEntryMoveError.publish({
+        entry,
+        model,
+        folderId,
+        error: ex
+      });
+      throw _error.default.from(ex, {
+        message: `Could not move entry "${id}" of model "${model.modelId}".`,
+        code: "MOVE_ENTRY_ERROR"
       });
     }
-    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-      context,
+  };
+  const republishEntry = async (model, id) => {
+    await accessControl.ensureCanAccessEntry({
       model,
-      input: originalEntry.values,
-      validateEntries: false
+      rwd: "w",
+      pw: "p"
     });
-    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-      savedOn: new Date().toISOString(),
-      webinyVersion: context.WEBINY_VERSION,
-      values
+
+    /**
+     * Fetch the entry from the storage.
+     */
+    const originalStorageEntry = await getRevisionByIdUseCase.execute(model, {
+      id
+    });
+    if (!originalStorageEntry) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${id}" was not found!`);
+    }
+    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+    await accessControl.ensureCanAccessEntry({
+      model,
+      entry: originalEntry,
+      rwd: "w",
+      pw: "p"
+    });
+    const {
+      entry
+    } = await (0, _entryDataFactories.createRepublishEntryData)({
+      context,
+      model,
+      originalEntry,
+      getIdentity: getSecurityIdentity
     });
     const storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
     /**
@@ -854,9 +663,9 @@ const createContentEntryCrud = params => {
       await onEntryAfterRepublish.publish({
         entry,
         model,
-        storageEntry
+        storageEntry: result
       });
-      return result;
+      return entry;
     } catch (ex) {
       await onEntryRepublishError.publish({
         entry,
@@ -868,53 +677,70 @@ const createContentEntryCrud = params => {
       });
     }
   };
-  const deleteEntryRevision = async (initialModel, revisionId) => {
-    const permission = await checkEntryPermissions({
+  const deleteEntryRevision = async (model, revisionId) => {
+    await accessControl.ensureCanAccessEntry({
+      model,
       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, {
+    const storageEntryToDelete = await getRevisionByIdUseCase.execute(model, {
       id: revisionId
     });
-    const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+    const latestStorageEntry = await getLatestRevisionByEntryIdUseCase.execute(model, {
       id: entryId
     });
-    const previousStorageEntry = await storageOperations.entries.getPreviousRevision(model, {
+    const storagePreviousEntry = await getPreviousRevisionByEntryIdUseCase.execute(model, {
       entryId,
       version: version
     });
     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);
+    await accessControl.ensureCanAccessEntry({
+      model,
+      entry: entryToDelete,
+      rwd: "d"
+    });
+
     /**
-     * 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 targeted record is the latest entry record and there is no previous one, we need
+     * to run full delete with hooks. In this case, `deleteRevision` hooks are not fired.
      */
-    if (entryToDelete.id === latestEntryRevisionId && !previousStorageEntry) {
-      return await deleteEntryHelper({
-        model,
+    if (entryToDelete.id === latestEntryRevisionId && !storagePreviousEntry) {
+      return await deleteEntryOperation.execute(model, {
         entry: entryToDelete
       });
     }
     /**
-     * If targeted record is latest entry revision, set the previous one as the new latest
+     * If targeted record is the 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;
+    let updatedEntryToSetAsLatest = null;
+    let storageUpdatedEntryToSetAsLatest = null;
+    if (entryToDelete.id === latestEntryRevisionId && storagePreviousEntry) {
+      entryToSetAsLatest = await (0, _entryStorage.entryFromStorageTransform)(context, model, storagePreviousEntry);
+      storageEntryToSetAsLatest = storagePreviousEntry;
+
+      /**
+       * Since we're setting a different revision as the latest, we need to update entry-level meta
+       * fields. The values are taken from the latest revision we're about to delete. The update of the
+       * new latest revision is performed within storage operations.
+       */
+      const pickedEntryLevelMetaFields = (0, _constants.pickEntryMetaFields)(entryToDelete, _constants.isEntryLevelEntryMetaField);
+      updatedEntryToSetAsLatest = {
+        ...entryToSetAsLatest,
+        ...pickedEntryLevelMetaFields
+      };
+      storageUpdatedEntryToSetAsLatest = {
+        ...storageEntryToSetAsLatest,
+        ...pickedEntryLevelMetaFields
+      };
     }
     try {
       await onEntryRevisionBeforeDelete.publish({
@@ -924,8 +750,8 @@ const createContentEntryCrud = params => {
       await storageOperations.entries.deleteRevision(model, {
         entry: entryToDelete,
         storageEntry: storageEntryToDelete,
-        latestEntry: entryToSetAsLatest,
-        latestStorageEntry: storageEntryToSetAsLatest
+        latestEntry: updatedEntryToSetAsLatest,
+        latestStorageEntry: storageUpdatedEntryToSetAsLatest
       });
       await onEntryRevisionAfterDelete.publish({
         entry: entryToDelete,
@@ -941,60 +767,135 @@ const createContentEntryCrud = params => {
         error: ex,
         entry: entryToDelete,
         storageEntry: storageEntryToDelete,
-        latestEntry: entryToSetAsLatest,
-        latestStorageEntry: storageEntryToSetAsLatest
+        latestEntry: updatedEntryToSetAsLatest,
+        latestStorageEntry: storageUpdatedEntryToSetAsLatest
       });
     }
   };
-  const deleteEntry = async (initialModel, entryId) => {
-    const permission = await checkEntryPermissions({
+  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 accessControl.ensureCanAccessEntry({
+      model,
       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
+    const {
+      items: entries
+    } = await storageOperations.entries.list(model, {
+      where: {
+        latest: true,
+        entryId_in: ids
+      },
+      limit: maxDeletableEntries + 1
     });
-    if (!storageEntry) {
-      throw new _handlerGraphql.NotFoundError(`Entry "${entryId}" was not found!`);
+    /**
+     * 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 accessControl.canAccessEntry({
+        model,
+        entry: entry
+      });
+    })).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
+      });
     }
-    (0, _ownership.checkOwnership)(context, permission, storageEntry);
-    const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntry);
-    return await deleteEntryHelper({
-      model,
-      entry
-    });
   };
-  const publishEntry = async (initialModel, id) => {
-    const permission = await checkEntryPermissions({
+  const deleteEntry = async (model, id, options = {}) => {
+    const {
+      permanently = true
+    } = options;
+
+    /**
+     * If the 'permanently' flag is set to false, the entry must be moved to the bin; otherwise, deleted.
+     */
+    if (!permanently) {
+      return await moveEntryToBinUseCase.execute(model, id, options);
+    }
+    return await deleteEntryUseCase.execute(model, id, options);
+  };
+  const publishEntry = async (model, id) => {
+    await accessControl.ensureCanAccessEntry({
+      model,
       pw: "p"
     });
-    await (0, _access.checkModelAccess)(context, initialModel);
-    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-      model: initialModel,
-      plugins
-    });
-    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+    const originalStorageEntry = await getRevisionByIdUseCase.execute(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
+    await accessControl.ensureCanAccessEntry({
+      model,
+      entry: originalEntry,
+      pw: "p"
+    });
+
+    // We need the latest entry to get the latest entry-level meta fields.
+    const latestStorageEntry = await getLatestRevisionByEntryIdUseCase.execute(model, {
+      id: originalEntry.entryId
+    });
+    if (!latestStorageEntry) {
+      throw new _handlerGraphql.NotFoundError(`Entry "${id}" in the model "${model.modelId}" was not found.`);
+    }
+    const latestEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, latestStorageEntry);
+    const {
+      entry
+    } = await (0, _entryDataFactories.createPublishEntryData)({
+      context,
+      model,
+      originalEntry,
+      latestEntry,
+      getIdentity: getSecurityIdentity
     });
     let storageEntry = null;
     try {
       await onEntryBeforePublish.publish({
+        original: originalEntry,
         entry,
         model
       });
@@ -1004,13 +905,15 @@ const createContentEntryCrud = params => {
         storageEntry
       });
       await onEntryAfterPublish.publish({
+        original: originalEntry,
         entry,
         storageEntry: result,
         model
       });
-      return result;
+      return entry;
     } catch (ex) {
       await onEntryPublishError.publish({
+        original: originalEntry,
         entry,
         model,
         error: ex
@@ -1024,18 +927,15 @@ const createContentEntryCrud = params => {
       });
     }
   };
-  const unpublishEntry = async (initialModel, id) => {
-    const permission = await checkEntryPermissions({
+  const unpublishEntry = async (model, id) => {
+    await accessControl.ensureCanAccessEntry({
+      model,
       pw: "u"
     });
-    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
-      model: initialModel,
-      plugins
-    });
     const {
       id: entryId
     } = (0, _utils.parseIdentifier)(id);
-    const originalStorageEntry = await storageOperations.entries.getPublishedRevisionByEntryId(model, {
+    const originalStorageEntry = await getPublishedRevisionByEntryIdUseCase.execute(model, {
       id: entryId
     });
     if (!originalStorageEntry) {
@@ -1046,10 +946,19 @@ const createContentEntryCrud = params => {
         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
+    await accessControl.ensureCanAccessEntry({
+      model,
+      entry: originalEntry,
+      pw: "u"
+    });
+    const {
+      entry
+    } = await (0, _entryDataFactories.createUnpublishEntryData)({
+      context,
+      model,
+      originalEntry,
+      getIdentity: getSecurityIdentity
     });
     let storageEntry = null;
     try {
@@ -1067,7 +976,7 @@ const createContentEntryCrud = params => {
         storageEntry: result,
         model
       });
-      return result;
+      return entry;
     } catch (ex) {
       await onEntryUnpublishError.publish({
         entry,
@@ -1082,73 +991,109 @@ const createContentEntryCrud = params => {
       });
     }
   };
-  return {
+  const getUniqueFieldValues = async (model, params) => {
+    await accessControl.ensureCanAccessEntry({
+      model
+    });
+    const {
+      where: initialWhere,
+      fieldId
+    } = params;
+    const where = {
+      ...initialWhere
+    };
     /**
-     * Deprecated - will be removed in 5.35.0
+     * 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.
      */
-    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,
+    if (await accessControl.canAccessOnlyOwnedEntries({
+      model
+    })) {
+      where.createdBy = getSecurityIdentity().id;
+    }
+
     /**
-     * Released in 5.34.0
-     *
-     * Create
+     * 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
+      });
+    }
+  };
+  const getEntryTraverser = async modelId => {
+    const modelAstConverter = context.cms.getModelToAstConverter();
+    const model = await context.cms.getModel(modelId);
+    if (!model) {
+      throw new Error(`Missing "${modelId}" model!`);
+    }
+    const modelAst = modelAstConverter.toAst(model);
+    return new _ContentEntryTraverser.ContentEntryTraverser(modelAst);
+  };
+  return {
+    getEntryTraverser,
     onEntryBeforeCreate,
     onEntryAfterCreate,
     onEntryCreateError,
-    /**
-     * Create revision
-     */
     onEntryRevisionBeforeCreate: onEntryBeforeCreateRevision,
     onEntryRevisionAfterCreate,
     onEntryRevisionCreateError: onEntryCreateRevisionError,
-    /**
-     * Update
-     */
     onEntryBeforeUpdate,
     onEntryAfterUpdate,
     onEntryUpdateError,
-    /**
-     * Delete whole entry
-     */
+    onEntryBeforeMove,
+    onEntryAfterMove,
+    onEntryMoveError,
     onEntryBeforeDelete,
     onEntryAfterDelete,
     onEntryDeleteError,
-    /**
-     * Delete entry revision
-     */
+    onEntryBeforeRestoreFromBin,
+    onEntryAfterRestoreFromBin,
+    onEntryRestoreFromBinError,
     onEntryRevisionBeforeDelete,
     onEntryRevisionAfterDelete,
     onEntryRevisionDeleteError,
-    /**
-     * Publish
-     */
     onEntryBeforePublish,
     onEntryAfterPublish,
     onEntryPublishError,
-    /**
-     * Republish
-     */
     onEntryBeforeRepublish,
     onEntryAfterRepublish,
     onEntryRepublishError,
-    /**
-     * Unpublish
-     */
     onEntryBeforeUnpublish,
     onEntryAfterUnpublish,
     onEntryUnpublishError,
@@ -1157,7 +1102,13 @@ const createContentEntryCrud = params => {
     /**
      * Get entries by exact revision IDs from the database.
      */
-    getEntriesByIds,
+    async getEntriesByIds(model, ids) {
+      return context.benchmark.measure("headlessCms.crud.entries.getEntriesByIds", async () => {
+        return getEntriesByIdsUseCase.execute(model, {
+          ids
+        });
+      });
+    },
     /**
      * Get a single entry by revision ID from the database.
      */
@@ -1171,7 +1122,9 @@ const createContentEntryCrud = params => {
      */
     async getPublishedEntriesByIds(model, ids) {
       return context.benchmark.measure("headlessCms.crud.entries.getPublishedEntriesByIds", async () => {
-        return getPublishedEntriesByIds(model, ids);
+        return getPublishedEntriesByIdsUseCase.execute(model, {
+          ids
+        });
       });
     },
     /**
@@ -1179,22 +1132,24 @@ const createContentEntryCrud = params => {
      */
     async getLatestEntriesByIds(model, ids) {
       return context.benchmark.measure("headlessCms.crud.entries.getLatestEntriesByIds", async () => {
-        return getLatestEntriesByIds(model, ids);
+        return await getLatestEntriesByIdsUseCase.execute(model, {
+          ids
+        });
       });
     },
     async getEntryRevisions(model, entryId) {
       return context.benchmark.measure("headlessCms.crud.entries.getEntryRevisions", async () => {
-        return getEntryRevisions(model, entryId);
+        return getRevisionsByEntryIdUseCase.execute(model, {
+          id: 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);
+        return await getEntryUseCase.execute(model, params);
       });
     },
     /**
@@ -1204,42 +1159,47 @@ const createContentEntryCrud = params => {
      */
     async listEntries(model, params) {
       return context.benchmark.measure("headlessCms.crud.entries.listEntries", async () => {
-        return listEntries(model, params);
+        return await listEntriesUseCase.execute(model, params);
       });
     },
     async listLatestEntries(model, params) {
-      const where = (params === null || params === void 0 ? void 0 : params.where) || {};
-      return this.listEntries(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({
-        sort: ["createdOn_DESC"]
-      }, params || {}), {}, {
-        where: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, where), {}, {
-          latest: true
-        })
-      }));
+      return context.benchmark.measure("headlessCms.crud.entries.listLatestEntries", async () => {
+        return await listLatestUseCase.execute(model, params);
+      });
+    },
+    async listDeletedEntries(model, params) {
+      return context.benchmark.measure("headlessCms.crud.entries.listDeletedEntries", async () => {
+        return await listDeletedUseCase.execute(model, params);
+      });
     },
     async listPublishedEntries(model, params) {
-      const where = (params === null || params === void 0 ? void 0 : params.where) || {};
-      return this.listEntries(model, (0, _objectSpread2.default)((0, _objectSpread2.default)({
-        sort: ["createdOn_DESC"]
-      }, params || {}), {}, {
-        where: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, where), {}, {
-          published: true
-        })
-      }));
+      return context.benchmark.measure("headlessCms.crud.entries.listPublishedEntries", async () => {
+        return await listPublishedUseCase.execute(model, params);
+      });
     },
-    async createEntry(model, input) {
+    async createEntry(model, input, options) {
       return context.benchmark.measure("headlessCms.crud.entries.createEntry", async () => {
-        return createEntry(model, input);
+        return createEntry(model, input, options);
       });
     },
-    async createEntryRevisionFrom(model, sourceId, input) {
+    async createEntryRevisionFrom(model, sourceId, input, options) {
       return context.benchmark.measure("headlessCms.crud.entries.createEntryRevisionFrom", async () => {
-        return createEntryRevisionFrom(model, sourceId, input);
+        return createEntryRevisionFrom(model, sourceId, input, options);
       });
     },
-    async updateEntry(model, id, input, meta) {
+    async updateEntry(model, id, input, meta, options) {
       return context.benchmark.measure("headlessCms.crud.entries.updateEntry", async () => {
-        return updateEntry(model, id, input, meta);
+        return updateEntry(model, id, input, meta, options);
+      });
+    },
+    async validateEntry(model, id, input) {
+      return context.benchmark.measure("headlessCms.crud.entries.validateEntry", async () => {
+        return validateEntry(model, id, input);
+      });
+    },
+    async moveEntry(model, id, folderId) {
+      return context.benchmark.measure("headlessCms.crud.entries.moveEntry", async () => {
+        return moveEntry(model, id, folderId);
       });
     },
     /**
@@ -1256,9 +1216,19 @@ const createContentEntryCrud = params => {
         return deleteEntryRevision(model, id);
       });
     },
-    async deleteEntry(model, entryId) {
+    async deleteEntry(model, entryId, options) {
       return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async () => {
-        return deleteEntry(model, entryId);
+        return deleteEntry(model, entryId, options);
+      });
+    },
+    async restoreEntryFromBin(model, entryId) {
+      return context.benchmark.measure("headlessCms.crud.entries.restoreEntryFromBin", async () => {
+        return await restoreEntryFromBinUseCase.execute(model, entryId);
+      });
+    },
+    async deleteMultipleEntries(model, ids) {
+      return context.benchmark.measure("headlessCms.crud.entries.deleteMultipleEntries", async () => {
+        return deleteMultipleEntries(model, ids);
       });
     },
     async publishEntry(model, id) {
@@ -1270,7 +1240,14 @@ const createContentEntryCrud = params => {
       return context.benchmark.measure("headlessCms.crud.entries.unpublishEntry", async () => {
         return unpublishEntry(model, id);
       });
+    },
+    async getUniqueFieldValues(model, params) {
+      return context.benchmark.measure("headlessCms.crud.entries.getUniqueFieldValues", async () => {
+        return getUniqueFieldValues(model, params);
+      });
     }
   };
 };
-exports.createContentEntryCrud = createContentEntryCrud;
+exports.createContentEntryCrud = createContentEntryCrud;
+
+//# sourceMappingURL=contentEntry.crud.js.map