@webiny/api-headless-cms 0.0.0-unstable.de38392959 → 0.0.0-unstable.df7a8bb475

package/crud/contentEntry.crud.js

@@ -1,1175 +1,183 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-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 _afterDelete = require("./contentEntry/afterDelete");
-var _entryStorage = require("../utils/entryStorage");
-var _searchableFields = require("./contentEntry/searchableFields");
-var _filterAsync = require("../utils/filterAsync");
-var _apiSecurity = require("@webiny/api-security");
-var _constants = require("../constants");
-var _entryDataFactories = require("./contentEntry/entryDataFactories");
-const createSort = sort => {
-  if (Array.isArray(sort) && sort.filter(Boolean).length > 0) {
-    return sort;
-  }
-  return ["revisionCreatedOn_DESC"];
-};
-const createContentEntryCrud = params => {
+import WebinyError from "@webiny/error";
+import { ContentEntryTraverser } from "../utils/contentEntryTraverser/ContentEntryTraverser.js";
+import { CreateEntryUseCase } from "../features/contentEntry/CreateEntry/index.js";
+import { CreateEntryRevisionFromUseCase } from "../features/contentEntry/CreateEntryRevisionFrom/abstractions.js";
+import { UpdateEntryUseCase } from "../features/contentEntry/UpdateEntry/index.js";
+import { ValidateEntryUseCase } from "../features/contentEntry/ValidateEntry/abstractions.js";
+import { MoveEntryUseCase } from "../features/contentEntry/MoveEntry/abstractions.js";
+import { RepublishEntryUseCase } from "../features/contentEntry/RepublishEntry/abstractions.js";
+import { PublishEntryUseCase } from "../features/contentEntry/PublishEntry/abstractions.js";
+import { ListDeletedEntriesUseCase, ListLatestEntriesUseCase, ListPublishedEntriesUseCase } from "../features/contentEntry/ListEntries/index.js";
+import { ListEntriesUseCase } from "../features/contentEntry/ListEntries/abstractions.js";
+import { GetEntriesByIdsUseCase } from "../features/contentEntry/GetEntriesByIds/index.js";
+import { GetEntryByIdUseCase } from "../features/contentEntry/GetEntryById/index.js";
+import { GetPublishedEntriesByIdsUseCase } from "../features/contentEntry/GetPublishedEntriesByIds/index.js";
+import { GetLatestEntriesByIdsUseCase } from "../features/contentEntry/GetLatestEntriesByIds/index.js";
+import { GetRevisionsByEntryIdUseCase } from "../features/contentEntry/GetRevisionsByEntryId/index.js";
+import { GetEntryUseCase } from "../features/contentEntry/GetEntry/index.js";
+import { DeleteEntryRevisionUseCase } from "../features/contentEntry/DeleteEntryRevision/index.js";
+import { DeleteEntryUseCase } from "../features/contentEntry/DeleteEntry/index.js";
+import { DeleteMultipleEntriesUseCase } from "../features/contentEntry/DeleteMultipleEntries/abstractions.js";
+import { RestoreEntryFromBinUseCase } from "../features/contentEntry/RestoreEntryFromBin/abstractions.js";
+import { UnpublishEntryUseCase } from "../features/contentEntry/UnpublishEntry/index.js";
+import { GetUniqueFieldValuesUseCase } from "../features/contentEntry/GetUniqueFieldValues/index.js";
+export const createContentEntryCrud = params => {
   const {
-    storageOperations,
-    entriesPermissions,
-    modelsPermissions,
-    context,
-    getIdentity: getSecurityIdentity,
-    getTenant,
-    getLocale
+    context
   } = params;
-
-  /**
-   * Create
-   */
-  const onEntryBeforeCreate = (0, _pubsub.createTopic)("cms.onEntryBeforeCreate");
-  const onEntryAfterCreate = (0, _pubsub.createTopic)("cms.onEntryAfterCreate");
-  const onEntryCreateError = (0, _pubsub.createTopic)("cms.onEntryCreateError");
-
-  /**
-   * 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
-   */
-  const onEntryBeforeUpdate = (0, _pubsub.createTopic)("cms.onEntryBeforeUpdate");
-  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
-   */
-  const onEntryBeforePublish = (0, _pubsub.createTopic)("cms.onEntryBeforePublish");
-  const onEntryAfterPublish = (0, _pubsub.createTopic)("cms.onEntryAfterPublish");
-  const onEntryPublishError = (0, _pubsub.createTopic)("cms.onEntryPublishError");
-
-  /**
-   * 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
-   */
-  const onEntryBeforeDelete = (0, _pubsub.createTopic)("cms.onEntryBeforeDelete");
-  const onEntryAfterDelete = (0, _pubsub.createTopic)("cms.onEntryAfterDelete");
-  const onEntryDeleteError = (0, _pubsub.createTopic)("cms.onEntryDeleteError");
-
-  /**
-   * 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
-   */
-  const onEntryBeforeGet = (0, _pubsub.createTopic)("cms.onEntryBeforeGet");
-
-  /**
-   * List entries
-   */
-  const onEntryBeforeList = (0, _pubsub.createTopic)("cms.onEntryBeforeList");
-
-  /**
-   * We need to assign some default behaviors.
-   */
-  (0, _beforeCreate.assignBeforeEntryCreate)({
-    context,
-    onEntryBeforeCreate
-  });
-  (0, _beforeUpdate.assignBeforeEntryUpdate)({
-    context,
-    onEntryBeforeUpdate
-  });
-  (0, _afterDelete.assignAfterEntryDelete)({
-    context,
-    onEntryAfterDelete
-  });
-
-  /**
-   * A helper to delete the entire entry.
-   */
-  const deleteEntryHelper = async params => {
-    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 modelsPermissions.ensureCanAccessModel({
-        model
-      });
-      const entries = await storageOperations.entries.getByIds(model, {
-        ids
-      });
-      return (0, _filterAsync.filterAsync)(entries, async entry => {
-        return entriesPermissions.ensure({
-          owns: entry.revisionCreatedBy
-        }, {
-          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;
-  };
-  const getPublishedEntriesByIds = async (model, ids) => {
-    await entriesPermissions.ensure({
-      rwd: "r"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    const entries = await storageOperations.entries.getPublishedByIds(model, {
-      ids
-    });
-    return (0, _filterAsync.filterAsync)(entries, async entry => {
-      return entriesPermissions.ensure({
-        owns: entry.revisionCreatedBy
-      }, {
-        throw: false
-      });
-    });
-  };
-  const getLatestEntriesByIds = async (model, ids) => {
-    await entriesPermissions.ensure({
-      rwd: "r"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    const entries = await storageOperations.entries.getLatestByIds(model, {
-      ids
-    });
-    return (0, _filterAsync.filterAsync)(entries, async entry => {
-      return entriesPermissions.ensure({
-        owns: entry.revisionCreatedBy
-      }, {
-        throw: false
-      });
-    });
-  };
-  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"
-      });
-    } catch {
-      throw new _apiSecurity.NotAuthorizedError({
-        data: {
-          reason: 'Not allowed to perform "read" on "cms.contentEntry".'
-        }
-      });
-    }
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    const {
-      where: initialWhere,
-      limit: initialLimit
-    } = params;
-    const limit = initialLimit && initialLimit > 0 ? initialLimit : 50;
-    const where = {
-      ...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.createdBy = getSecurityIdentity().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
-      });
-    }
-    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, {
-        ...params,
-        sort: createSort(params.sort),
-        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 (model, rawInput, options) => {
-    await entriesPermissions.ensure({
-      rwd: "w"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    const {
-      entry,
-      input
-    } = await (0, _entryDataFactories.createEntryData)({
-      context,
-      model,
-      options,
-      rawInput,
-      getLocale,
-      getTenant,
-      getIdentity: getSecurityIdentity,
-      entriesPermissions
-    });
-    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 entry;
-    } 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
-      });
-    }
+    // Delegate to new CreateEntry use case
+    const useCase = context.container.resolve(CreateEntryUseCase);
+    const result = await useCase.execute(model, rawInput, options);
+    if (result.isFail()) {
+      // Convert Result error to WebinyError for backward compatibility
+      const error = result.error;
+      throw new WebinyError(error.message || "Could not create content entry.", error.code || "CREATE_ENTRY_ERROR", error.data);
+    }
+    return result.value;
   };
   const createEntryRevisionFrom = async (model, sourceId, rawInput, options) => {
-    await entriesPermissions.ensure({
-      rwd: "w"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-
-    /**
-     * 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.`);
-    }
-    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);
-    await entriesPermissions.ensure({
-      owns: originalEntry.createdBy
-    });
-    const {
-      entry,
-      input
-    } = await (0, _entryDataFactories.createEntryRevisionFromData)({
-      sourceId,
-      model,
-      rawInput,
-      options,
-      context,
-      getIdentity: getSecurityIdentity,
-      getTenant,
-      getLocale,
-      originalEntry,
-      latestStorageEntry
-    });
-    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 entry;
-    } 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
-      });
-    }
+    // Delegate to new CreateEntryRevisionFrom use case
+    const useCase = context.container.resolve(CreateEntryRevisionFromUseCase);
+    const result = await useCase.execute(model, sourceId, rawInput, options);
+    if (result.isFail()) {
+      // Convert Result error to WebinyError for backward compatibility
+      const error = result.error;
+      throw new WebinyError(error.message || "Could not create entry from existing one.", error.code || "CREATE_FROM_REVISION_ERROR", error.data);
+    }
+    return result.value;
   };
   const updateEntry = async (model, id, rawInput, metaInput, options) => {
-    await entriesPermissions.ensure({
-      rwd: "w"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-
-    /**
-     * 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 entriesPermissions.ensure({
-      owns: originalEntry.revisionCreatedBy
-    });
-    const {
-      entry,
-      input
-    } = await (0, _entryDataFactories.createUpdateEntryData)({
-      model,
-      rawInput,
-      options,
-      context,
-      getIdentity: getSecurityIdentity,
-      getTenant,
-      getLocale,
-      originalEntry,
-      metaInput
-    });
-    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 entry;
-    } 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
-      });
-    }
+    // Delegate to new UpdateEntry use case
+    const useCase = context.container.resolve(UpdateEntryUseCase);
+    const result = await useCase.execute(model, id, rawInput, metaInput, options);
+    if (result.isFail()) {
+      // Convert Result error to WebinyError for backward compatibility
+      const error = result.error;
+      throw new WebinyError(error.message || "Could not update existing entry.", error.code || "UPDATE_ERROR");
+    }
+    return result.value;
   };
-  const validateEntry = async (model, id, inputData) => {
-    await entriesPermissions.ensure({
-      rwd: "w"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    const input = (0, _entryDataFactories.mapAndCleanUpdatedInputData)(model, inputData || {});
-    let originalEntry;
-    if (id) {
-      /**
-       * 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.`);
-      }
-      originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-    }
-    const result = await (0, _entryDataValidation.validateModelEntryData)({
-      context,
-      model,
-      data: input,
-      entry: originalEntry
-    });
-    return result.length > 0 ? result : [];
+  const validateEntry = async (model, id, input) => {
+    // Delegate to new ValidateEntry use case
+    const useCase = context.container.resolve(ValidateEntryUseCase);
+    const result = await useCase.execute(model, id || null, input);
+    if (result.isFail()) {
+      // Convert Result error to WebinyError for backward compatibility
+      const error = result.error;
+      throw new WebinyError(error.message || "Could not validate entry.", error.code || "VALIDATION_ERROR", error.data);
+    }
+    return result.value;
   };
   const moveEntry = async (model, id, folderId) => {
-    await entriesPermissions.ensure({
-      rwd: "w"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    /**
-     * The entry we are going to move to another folder.
-     */
-    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-      id
-    });
-    if (!originalStorageEntry) {
-      throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
-    }
-    const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-    /**
-     * No need to continue if the entry is already in the requested folder.
-     */
-    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"
-      });
-    }
+    // Delegate to new MoveEntry use case
+    const useCase = context.container.resolve(MoveEntryUseCase);
+    const result = await useCase.execute(model, id, folderId);
+    if (result.isFail()) {
+      // Convert Result error to WebinyError for backward compatibility
+      const error = result.error;
+      throw new WebinyError(error.message || `Could not move entry "${id}" of model "${model.modelId}".`, error.code || "MOVE_ENTRY_ERROR", error.data);
+    }
+    return result.value;
   };
   const republishEntry = async (model, id) => {
-    await entriesPermissions.ensure({
-      rwd: "w"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-
-    /**
-     * 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);
-    const {
-      entry
-    } = await (0, _entryDataFactories.createRepublishEntryData)({
-      context,
-      model,
-      originalEntry,
-      getIdentity: getSecurityIdentity
-    });
-    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: result
-      });
-      return entry;
-    } 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
-      });
-    }
+    // Delegate to new RepublishEntry use case
+    const useCase = context.container.resolve(RepublishEntryUseCase);
+    const result = await useCase.execute(model, id);
+    if (result.isFail()) {
+      // Convert Result error to WebinyError for backward compatibility
+      const error = result.error;
+      throw new WebinyError(error.message || "Could not republish entry.", error.code || "REPUBLISH_ERROR", error.data);
+    }
+    return result.value;
   };
   const deleteEntryRevision = async (model, revisionId) => {
-    await entriesPermissions.ensure({
-      rwd: "d"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    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 storagePreviousEntry = await storageOperations.entries.getPreviousRevision(model, {
-      entryId,
-      version: version
-    });
-    if (!storageEntryToDelete) {
-      throw new _handlerGraphql.NotFoundError(`Entry "${revisionId}" was not found!`);
-    }
-    await entriesPermissions.ensure({
-      owns: storageEntryToDelete.revisionCreatedBy
-    });
-    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. In this case, `deleteRevision` hooks are not fired.
-     */
-    if (entryToDelete.id === latestEntryRevisionId && !storagePreviousEntry) {
-      return await deleteEntryHelper({
-        model,
-        entry: entryToDelete
-      });
-    }
-    /**
-     * If targeted record is the latest entry revision, set the previous one as the new latest.
-     */
-    let entryToSetAsLatest = null;
-    let storageEntryToSetAsLatest = null;
-    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({
-        entry: entryToDelete,
-        model
-      });
-      await storageOperations.entries.deleteRevision(model, {
-        entry: entryToDelete,
-        storageEntry: storageEntryToDelete,
-        latestEntry: updatedEntryToSetAsLatest,
-        latestStorageEntry: storageUpdatedEntryToSetAsLatest
-      });
-      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: updatedEntryToSetAsLatest,
-        latestStorageEntry: storageUpdatedEntryToSetAsLatest
-      });
+    const useCase = context.container.resolve(DeleteEntryRevisionUseCase);
+    const result = await useCase.execute(model, revisionId);
+    if (result.isFail()) {
+      throw new WebinyError(result.error.message, result.error.code, result.error.data);
     }
   };
   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
-    });
-    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
-    });
-    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
-    });
+    // Delegate to new DeleteMultipleEntries use case
+    const useCase = context.container.resolve(DeleteMultipleEntriesUseCase);
+    const result = await useCase.execute(model, params);
+    if (result.isFail()) {
+      // Convert Result error to WebinyError for backward compatibility
+      const error = result.error;
+      throw new WebinyError(error.message || "Could not delete multiple entries.", error.code || "DELETE_ENTRIES_MULTIPLE_ERROR", error.data);
+    }
+    return result.value;
   };
   const publishEntry = async (model, id) => {
-    await entriesPermissions.ensure({
-      pw: "p"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    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.revisionCreatedBy
-    });
-    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-
-    // We need the latest entry to get the latest entry-level meta fields.
-    const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(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
-      });
-      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-      const result = await storageOperations.entries.publish(model, {
-        entry,
-        storageEntry
-      });
-      await onEntryAfterPublish.publish({
-        original: originalEntry,
-        entry,
-        storageEntry: result,
-        model
-      });
-      return entry;
-    } catch (ex) {
-      await onEntryPublishError.publish({
-        original: originalEntry,
-        entry,
-        model,
-        error: ex
-      });
-      throw new _error.default(ex.message || "Could not publish entry.", ex.code || "PUBLISH_ERROR", {
-        error: ex,
-        entry,
-        storageEntry,
-        originalEntry,
-        originalStorageEntry
-      });
-    }
+    // Delegate to new PublishEntry use case
+    const useCase = context.container.resolve(PublishEntryUseCase);
+    const result = await useCase.execute(model, id);
+    if (result.isFail()) {
+      // Convert Result error to WebinyError for backward compatibility
+      throw new WebinyError(result.error.message || "Could not publish entry.", result.error.code || "PUBLISH_ERROR", result.error.data);
+    }
+    return result.value;
   };
   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.revisionCreatedBy
-    });
-    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-    const {
-      entry
-    } = await (0, _entryDataFactories.createUnpublishEntryData)({
-      context,
-      model,
-      originalEntry,
-      getIdentity: getSecurityIdentity
-    });
-    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 entry;
-    } 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
-      });
-    }
+    // Delegate to new UnpublishEntry use case
+    const useCase = context.container.resolve(UnpublishEntryUseCase);
+    const result = await useCase.execute(model, id);
+    if (result.isFail()) {
+      const error = result.error;
+      throw new WebinyError(error.message || "Could not unpublish entry.", error.code || "UNPUBLISH_ERROR", error.data);
+    }
+    return result.value;
   };
   const getUniqueFieldValues = async (model, params) => {
-    await entriesPermissions.ensure({
-      rwd: "r"
-    });
-    await modelsPermissions.ensureCanAccessModel({
-      model
-    });
-    const {
-      where: initialWhere,
-      fieldId
-    } = params;
-    const where = {
-      ...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.createdBy = getSecurityIdentity().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
-      });
+    const useCase = context.container.resolve(GetUniqueFieldValuesUseCase);
+    const result = await useCase.execute(model, params);
+    if (result.isFail()) {
+      throw new WebinyError(result.error.message, result.error.code, result.error.data);
     }
+    return result.value;
+  };
+  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(modelAst);
   };
   return {
-    onEntryBeforeCreate,
-    onEntryAfterCreate,
-    onEntryCreateError,
-    onEntryRevisionBeforeCreate: onEntryBeforeCreateRevision,
-    onEntryRevisionAfterCreate,
-    onEntryRevisionCreateError: onEntryCreateRevisionError,
-    onEntryBeforeUpdate,
-    onEntryAfterUpdate,
-    onEntryUpdateError,
-    onEntryBeforeMove,
-    onEntryAfterMove,
-    onEntryMoveError,
-    onEntryBeforeDelete,
-    onEntryAfterDelete,
-    onEntryDeleteError,
-    onEntryRevisionBeforeDelete,
-    onEntryRevisionAfterDelete,
-    onEntryRevisionDeleteError,
-    onEntryBeforePublish,
-    onEntryAfterPublish,
-    onEntryPublishError,
-    onEntryBeforeRepublish,
-    onEntryAfterRepublish,
-    onEntryRepublishError,
-    onEntryBeforeUnpublish,
-    onEntryAfterUnpublish,
-    onEntryUnpublishError,
-    onEntryBeforeGet,
-    onEntryBeforeList,
+    getEntryTraverser,
     /**
      * Get entries by exact revision IDs from the database.
      */
-    getEntriesByIds,
+    async getEntriesByIds(model, ids) {
+      return context.benchmark.measure("headlessCms.crud.entries.getEntriesByIds", async () => {
+        const useCase = context.container.resolve(GetEntriesByIdsUseCase);
+        const result = await useCase.execute(model, ids);
+        if (result.isFail()) {
+          const error = result.error;
+          throw new WebinyError(error.message || "Could not get entries by IDs.", error.code || "GET_ENTRIES_BY_IDS_ERROR", {
+            error,
+            ids,
+            model
+          });
+        }
+        return result.value;
+      });
+    },
     /**
      * 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);
+        const useCase = context.container.resolve(GetEntryByIdUseCase);
+        const result = await useCase.execute(model, id);
+        if (result.isFail()) {
+          const error = result.error;
+          throw new WebinyError(error.message || `Entry by ID "${id}" not found.`, error.code || "GET_ENTRY_BY_ID_ERROR", error.data);
+        }
+        return result.value;
       });
     },
     /**
@@ -1177,7 +185,17 @@ const createContentEntryCrud = params => {
      */
     async getPublishedEntriesByIds(model, ids) {
       return context.benchmark.measure("headlessCms.crud.entries.getPublishedEntriesByIds", async () => {
-        return getPublishedEntriesByIds(model, ids);
+        const useCase = context.container.resolve(GetPublishedEntriesByIdsUseCase);
+        const result = await useCase.execute(model, ids);
+        if (result.isFail()) {
+          const error = result.error;
+          throw new WebinyError(error.message || "Could not get published entries by IDs.", error.code || "GET_PUBLISHED_ENTRIES_BY_IDS_ERROR", {
+            error,
+            ids,
+            model
+          });
+        }
+        return result.value;
       });
     },
     /**
@@ -1185,22 +203,50 @@ const createContentEntryCrud = params => {
      */
     async getLatestEntriesByIds(model, ids) {
       return context.benchmark.measure("headlessCms.crud.entries.getLatestEntriesByIds", async () => {
-        return getLatestEntriesByIds(model, ids);
+        const useCase = context.container.resolve(GetLatestEntriesByIdsUseCase);
+        const result = await useCase.execute(model, ids);
+        if (result.isFail()) {
+          const error = result.error;
+          throw new WebinyError(error.message || "Could not get latest entries by IDs.", error.code || "GET_LATEST_ENTRIES_BY_IDS_ERROR", {
+            error,
+            ids,
+            model
+          });
+        }
+        return result.value;
       });
     },
     async getEntryRevisions(model, entryId) {
       return context.benchmark.measure("headlessCms.crud.entries.getEntryRevisions", async () => {
-        return getEntryRevisions(model, entryId);
+        const useCase = context.container.resolve(GetRevisionsByEntryIdUseCase);
+        const result = await useCase.execute(model, entryId);
+        if (result.isFail()) {
+          const error = result.error;
+          throw new WebinyError(error.message || "Could not get entry revisions.", error.code || "GET_ENTRY_REVISIONS_ERROR", {
+            error,
+            entryId,
+            model
+          });
+        }
+        return result.value;
       });
     },
     /**
-     * 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);
+        const useCase = context.container.resolve(GetEntryUseCase);
+        const result = await useCase.execute(model, params);
+        if (result.isFail()) {
+          const error = result.error;
+          throw new WebinyError(error.message || "Entry not found!", error.code || "GET_ENTRY_ERROR", {
+            error,
+            params,
+            model
+          });
+        }
+        return result.value;
       });
     },
     /**
@@ -1209,31 +255,72 @@ const createContentEntryCrud = params => {
      * @internal
      */
     async listEntries(model, params) {
-      return context.benchmark.measure("headlessCms.crud.entries.listEntries", async () => {
-        return listEntries(model, params);
-      });
+      const useCase = context.container.resolve(ListEntriesUseCase);
+      const result = await useCase.execute(model, params);
+      if (result.isFail()) {
+        const error = result.error;
+        throw new WebinyError(error.message || "Could not list entries.", error.code || "LIST_ENTRIES_ERROR", {
+          error,
+          params,
+          model
+        });
+      }
+      const {
+        entries,
+        meta
+      } = result.value;
+      return [entries, meta];
     },
     async listLatestEntries(model, params) {
-      const where = params?.where || {};
-      return this.listEntries(model, {
-        sort: ["createdOn_DESC"],
-        ...(params || {}),
-        where: {
-          ...where,
-          latest: true
-        }
-      });
+      const useCase = context.container.resolve(ListLatestEntriesUseCase);
+      const result = await useCase.execute(model, params);
+      if (result.isFail()) {
+        const error = result.error;
+        throw new WebinyError(error.message || "Could not list latest entries.", error.code || "LIST_LATEST_ENTRIES_ERROR", {
+          error,
+          params,
+          model
+        });
+      }
+      const {
+        entries,
+        meta
+      } = result.value;
+      return [entries, meta];
+    },
+    async listDeletedEntries(model, params) {
+      const useCase = context.container.resolve(ListDeletedEntriesUseCase);
+      const result = await useCase.execute(model, params);
+      if (result.isFail()) {
+        const error = result.error;
+        throw new WebinyError(error.message || "Could not list deleted entries.", error.code || "LIST_DELETED_ENTRIES_ERROR", {
+          error,
+          params,
+          model
+        });
+      }
+      const {
+        entries,
+        meta
+      } = result.value;
+      return [entries, meta];
     },
     async listPublishedEntries(model, params) {
-      const where = params?.where || {};
-      return this.listEntries(model, {
-        sort: ["createdOn_DESC"],
-        ...(params || {}),
-        where: {
-          ...where,
-          published: true
-        }
-      });
+      const useCase = context.container.resolve(ListPublishedEntriesUseCase);
+      const result = await useCase.execute(model, params);
+      if (result.isFail()) {
+        const error = result.error;
+        throw new WebinyError(error.message || "Could not list published entries.", error.code || "LIST_PUBLISHED_ENTRIES_ERROR", {
+          error,
+          params,
+          model
+        });
+      }
+      const {
+        entries,
+        meta
+      } = result.value;
+      return [entries, meta];
     },
     async createEntry(model, input, options) {
       return context.benchmark.measure("headlessCms.crud.entries.createEntry", async () => {
@@ -1275,8 +362,22 @@ const createContentEntryCrud = params => {
       });
     },
     async deleteEntry(model, entryId, options) {
+      const deleteEntryUseCase = context.container.resolve(DeleteEntryUseCase);
       return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async () => {
-        return deleteEntry(model, entryId, options);
+        const result = await deleteEntryUseCase.execute(model, entryId, options ?? {});
+        if (result.isFail()) {
+          throw new WebinyError(result.error.message, result.error.code, result.error.data);
+        }
+      });
+    },
+    async restoreEntryFromBin(model, entryId) {
+      return context.benchmark.measure("headlessCms.crud.entries.restoreEntryFromBin", async () => {
+        const useCase = context.container.resolve(RestoreEntryFromBinUseCase);
+        const result = await useCase.execute(model, entryId);
+        if (result.isFail()) {
+          throw new WebinyError(result.error.message, result.error.code, result.error.data);
+        }
+        return result.value;
       });
     },
     async deleteMultipleEntries(model, ids) {
@@ -1301,6 +402,5 @@ const createContentEntryCrud = params => {
     }
   };
 };
-exports.createContentEntryCrud = createContentEntryCrud;
 
 //# sourceMappingURL=contentEntry.crud.js.map