@webiny/api-headless-cms 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/crud/contentEntry.crud.js

@@ -1,1212 +1,334 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-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"));
-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 _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";
-};
-const createContentEntryCrud = params => {
-  const {
-    storageOperations,
-    context,
-    getIdentity,
-    getTenant,
-    getLocale
-  } = params;
-  const getCreatedBy = () => {
-    const identity = getIdentity();
-    return {
-      id: identity.id,
-      displayName: identity.displayName,
-      type: identity.type
+import _webiny_error from "@webiny/error";
+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";
+import { UpdateRevisionDescriptionUseCase } from "../features/contentEntry/UpdateRevisionDescription/index.js";
+const createContentEntryCrud = (params)=>{
+    const { context } = params;
+    const createEntry = async (model, rawInput, options)=>{
+        const useCase = context.container.resolve(CreateEntryUseCase);
+        const result = await useCase.execute(model, rawInput, options);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not create content entry.", error.code || "CREATE_ENTRY_ERROR", error.data);
+        }
+        return result.value;
     };
-  };
-
-  /**
-   * 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");
-
-  /**
-   * 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");
-
-  /**
-   * 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
-  });
-  const checkEntryPermissions = check => {
-    return (0, _permissions.checkPermissions)(context, "cms.contentEntry", check);
-  };
-
-  /**
-   * A helper to delete the entire entry.
-   */
-  const deleteEntryHelper = async params => {
-    return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async () => {
-      const {
-        model,
-        entry
-      } = params;
-      try {
-        await onEntryBeforeDelete.publish({
-          entry,
-          model
-        });
-        await storageOperations.entries.delete(model, {
-          entry
-        });
-        await onEntryAfterDelete.publish({
-          entry,
-          model
-        });
-      } catch (ex) {
-        await onEntryDeleteError.publish({
-          entry,
-          model,
-          error: ex
-        });
-        throw new _error.default(ex.message || "Could not delete entry.", ex.code || "DELETE_ERROR", {
-          entry
-        });
-      }
-    });
-  };
-  /**
-   * A helper to get entries by revision IDs
-   */
-  const getEntriesByIds = async (model, ids) => {
-    return context.benchmark.measure("headlessCms.crud.entries.getEntriesByIds", async () => {
-      const permission = await checkEntryPermissions({
-        rwd: "r"
-      });
-      await (0, _access.checkModelAccess)(context, model);
-      const entries = await storageOperations.entries.getByIds(model, {
-        ids
-      });
-      return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
-    });
-  };
-  const getEntryById = async (model, id) => {
-    const where = {
-      id
+    const createEntryRevisionFrom = async (model, sourceId, rawInput, options)=>{
+        const useCase = context.container.resolve(CreateEntryRevisionFromUseCase);
+        const result = await useCase.execute(model, sourceId, rawInput, options);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(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, options)=>{
+        const useCase = context.container.resolve(UpdateEntryUseCase);
+        const result = await useCase.execute(model, id, rawInput, options);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not update existing entry.", error.code || "UPDATE_ERROR");
+        }
+        return result.value;
+    };
+    const updateRevisionDescription = async (model, id, revisionDescription)=>{
+        const useCase = context.container.resolve(UpdateRevisionDescriptionUseCase);
+        const result = await useCase.execute(model, id, revisionDescription);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not update revision description of the revision.", error.code || "UPDATE_REVISION_DESCRIPTION_ERROR");
+        }
+        return result.value;
+    };
+    const validateEntry = async (model, id, input)=>{
+        const useCase = context.container.resolve(ValidateEntryUseCase);
+        const result = await useCase.execute(model, id || null, input);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not validate entry.", error.code || "VALIDATION_ERROR", error.data);
+        }
+        return result.value;
+    };
+    const moveEntry = async (model, id, folderId)=>{
+        const useCase = context.container.resolve(MoveEntryUseCase);
+        const result = await useCase.execute(model, id, folderId);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(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)=>{
+        const useCase = context.container.resolve(RepublishEntryUseCase);
+        const result = await useCase.execute(model, id);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not republish entry.", error.code || "REPUBLISH_ERROR", error.data);
+        }
+        return result.value;
+    };
+    const deleteEntryRevision = async (model, revisionId)=>{
+        const useCase = context.container.resolve(DeleteEntryRevisionUseCase);
+        const result = await useCase.execute(model, revisionId);
+        if (result.isFail()) throw new _webiny_error(result.error.message, result.error.code, result.error.data);
+    };
+    const deleteMultipleEntries = async (model, params)=>{
+        const useCase = context.container.resolve(DeleteMultipleEntriesUseCase);
+        const result = await useCase.execute(model, params);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not delete multiple entries.", error.code || "DELETE_ENTRIES_MULTIPLE_ERROR", error.data);
+        }
+        return result.value;
+    };
+    const publishEntry = async (model, id)=>{
+        const useCase = context.container.resolve(PublishEntryUseCase);
+        const result = await useCase.execute(model, id);
+        if (result.isFail()) throw new _webiny_error(result.error.message || "Could not publish entry.", result.error.code || "PUBLISH_ERROR", result.error.data);
+        return result.value;
+    };
+    const unpublishEntry = async (model, id)=>{
+        const useCase = context.container.resolve(UnpublishEntryUseCase);
+        const result = await useCase.execute(model, id);
+        if (result.isFail()) {
+            const error = result.error;
+            throw new _webiny_error(error.message || "Could not unpublish entry.", error.code || "UNPUBLISH_ERROR", error.data);
+        }
+        return result.value;
     };
-    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) => {
-    const permission = await checkEntryPermissions({
-      rwd: "r"
-    });
-    await (0, _access.checkModelAccess)(context, model);
-    const entries = await storageOperations.entries.getPublishedByIds(model, {
-      ids
-    });
-    return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
-  };
-  const getLatestEntriesByIds = async (model, ids) => {
-    const permission = await checkEntryPermissions({
-      rwd: "r"
-    });
-    await (0, _access.checkModelAccess)(context, model);
-    const entries = await storageOperations.entries.getLatestByIds(model, {
-      ids
-    });
-    return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
-  };
-  const getEntry = async (model, params) => {
-    await checkEntryPermissions({
-      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) => {
-    const permission = await checkEntryPermissions({
-      rwd: "r"
-    });
-    await (0, _access.checkModelAccess)(context, model);
-    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
+    const getUniqueFieldValues = async (model, params)=>{
+        const useCase = context.container.resolve(GetUniqueFieldValuesUseCase);
+        const result = await useCase.execute(model, params);
+        if (result.isFail()) throw new _webiny_error(result.error.message, result.error.code, result.error.data);
+        return result.value;
+    };
+    return {
+        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 _webiny_error(error.message || "Could not get entries by IDs.", error.code || "GET_ENTRIES_BY_IDS_ERROR", {
+                        error,
+                        ids,
+                        model
+                    });
+                }
+                return result.value;
+            });
         },
-        model,
-        fields
-      });
-    }
-  };
-  const createEntry = async (model, inputData) => {
-    await checkEntryPermissions({
-      rwd: "w"
-    });
-    await (0, _access.checkModelAccess)(context, model);
-
-    /**
-     * Make sure we only work with fields that are defined in the model.
-     */
-    const initialInput = mapAndCleanCreateInputData(model, inputData);
-    await (0, _entryDataValidation.validateModelEntryData)({
-      context,
-      model,
-      data: initialInput
-    });
-    const input = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-      context,
-      model,
-      input: initialInput,
-      validateEntries: true
-    });
-    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
+        async getEntryById (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.getEntryById", async ()=>{
+                const useCase = context.container.resolve(GetEntryByIdUseCase);
+                const result = await useCase.execute(model, id);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || `Entry by ID "${id}" not found.`, error.code || "GET_ENTRY_BY_ID_ERROR", error.data);
+                }
+                return result.value;
+            });
+        },
+        async getPublishedEntriesByIds (model, ids) {
+            return context.benchmark.measure("headlessCms.crud.entries.getPublishedEntriesByIds", async ()=>{
+                const useCase = context.container.resolve(GetPublishedEntriesByIdsUseCase);
+                const result = await useCase.execute(model, ids);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || "Could not get published entries by IDs.", error.code || "GET_PUBLISHED_ENTRIES_BY_IDS_ERROR", {
+                        error,
+                        ids,
+                        model
+                    });
+                }
+                return result.value;
+            });
+        },
+        async getLatestEntriesByIds (model, ids) {
+            return context.benchmark.measure("headlessCms.crud.entries.getLatestEntriesByIds", async ()=>{
+                const useCase = context.container.resolve(GetLatestEntriesByIdsUseCase);
+                const result = await useCase.execute(model, ids);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(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 ()=>{
+                const useCase = context.container.resolve(GetRevisionsByEntryIdUseCase);
+                const result = await useCase.execute(model, entryId);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || "Could not get entry revisions.", error.code || "GET_ENTRY_REVISIONS_ERROR", {
+                        error,
+                        entryId,
+                        model
+                    });
+                }
+                return result.value;
+            });
+        },
+        async getEntry (model, params) {
+            return context.benchmark.measure("headlessCms.crud.entries.getEntry", async ()=>{
+                const useCase = context.container.resolve(GetEntryUseCase);
+                const result = await useCase.execute(model, params);
+                if (result.isFail()) {
+                    const error = result.error;
+                    throw new _webiny_error(error.message || "Entry not found!", error.code || "GET_ENTRY_ERROR", {
+                        error,
+                        params,
+                        model
+                    });
+                }
+                return result.value;
+            });
+        },
+        async 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 _webiny_error(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 useCase = context.container.resolve(ListLatestEntriesUseCase);
+            const result = await useCase.execute(model, params);
+            if (result.isFail()) {
+                const error = result.error;
+                throw new _webiny_error(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 _webiny_error(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 useCase = context.container.resolve(ListPublishedEntriesUseCase);
+            const result = await useCase.execute(model, params);
+            if (result.isFail()) {
+                const error = result.error;
+                throw new _webiny_error(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 ()=>createEntry(model, input, options));
+        },
+        async createEntryRevisionFrom (model, sourceId, input, options) {
+            return context.benchmark.measure("headlessCms.crud.entries.createEntryRevisionFrom", async ()=>createEntryRevisionFrom(model, sourceId, input, options));
+        },
+        async updateEntry (model, id, input, options) {
+            return context.benchmark.measure("headlessCms.crud.entries.updateEntry", async ()=>updateEntry(model, id, input, options));
+        },
+        async updateRevisionDescription (model, id, revisionDescription) {
+            return context.benchmark.measure("headlessCms.crud.entries.updateRevisionDescription", async ()=>updateRevisionDescription(model, id, revisionDescription));
+        },
+        async validateEntry (model, id, input) {
+            return context.benchmark.measure("headlessCms.crud.entries.validateEntry", async ()=>validateEntry(model, id, input));
+        },
+        async moveEntry (model, id, folderId) {
+            return context.benchmark.measure("headlessCms.crud.entries.moveEntry", async ()=>moveEntry(model, id, folderId));
+        },
+        async republishEntry (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.republishEntry", async ()=>republishEntry(model, id));
+        },
+        async deleteEntryRevision (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.deleteEntryRevision", async ()=>deleteEntryRevision(model, id));
+        },
+        async deleteEntry (model, entryId, options) {
+            const deleteEntryUseCase = context.container.resolve(DeleteEntryUseCase);
+            return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async ()=>{
+                const result = await deleteEntryUseCase.execute(model, entryId, options ?? {});
+                if (result.isFail()) throw new _webiny_error(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 _webiny_error(result.error.message, result.error.code, result.error.data);
+                return result.value;
+            });
+        },
+        async deleteMultipleEntries (model, ids) {
+            return context.benchmark.measure("headlessCms.crud.entries.deleteMultipleEntries", async ()=>deleteMultipleEntries(model, ids));
+        },
+        async publishEntry (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.publishEntry", async ()=>publishEntry(model, id));
+        },
+        async unpublishEntry (model, id) {
+            return context.benchmark.measure("headlessCms.crud.entries.unpublishEntry", async ()=>unpublishEntry(model, id));
+        },
+        async getUniqueFieldValues (model, params) {
+            return context.benchmark.measure("headlessCms.crud.entries.getUniqueFieldValues", async ()=>getUniqueFieldValues(model, params));
+        }
     };
-    let storageEntry = null;
-    try {
-      await onEntryBeforeCreate.publish({
-        entry,
-        input,
-        model
-      });
-      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-      const result = await storageOperations.entries.create(model, {
-        entry,
-        storageEntry
-      });
-      await onEntryAfterCreate.publish({
-        entry,
-        storageEntry: result,
-        model,
-        input
-      });
-      return result;
-    } catch (ex) {
-      await onEntryCreateError.publish({
-        error: ex,
-        entry,
-        model,
-        input
-      });
-      throw new _error.default(ex.message || "Could not create content entry.", ex.code || "CREATE_ENTRY_ERROR", ex.data || {
-        error: ex,
-        input,
-        entry,
-        storageEntry
-      });
-    }
-  };
-  const createEntryRevisionFrom = async (model, sourceId, inputData) => {
-    const permission = await checkEntryPermissions({
-      rwd: "w"
-    });
-    await (0, _access.checkModelAccess)(context, model);
-
-    /**
-     * Make sure we only work with fields that are defined in the model.
-     */
-    const input = mapAndCleanUpdatedInputData(model, inputData);
-
-    /**
-     * Entries are identified by a common parent ID + Revision number.
-     */
-    const {
-      id: uniqueId
-    } = (0, _utils.parseIdentifier)(sourceId);
-    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-      id: sourceId
-    });
-    const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-      id: uniqueId
-    });
-    if (!originalStorageEntry) {
-      throw new _handlerGraphql.NotFoundError(`Entry "${sourceId}" of model "${model.modelId}" was not found.`);
-    }
-
-    /**
-     * We need to convert data from DB to its original form before using it further.
-     */
-    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-    const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
-    await (0, _entryDataValidation.validateModelEntryData)({
-      context,
-      model,
-      data: initialValues,
-      entry: originalEntry
-    });
-    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-      context,
-      model,
-      input: initialValues,
-      validateEntries: false
-    });
-    (0, _ownership.checkOwnership)(context, permission, originalEntry);
-    const identity = getIdentity();
-    const latestId = latestStorageEntry ? latestStorageEntry.id : sourceId;
-    const {
-      id,
-      version: nextVersion
-    } = increaseEntryIdVersion(latestId);
-    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-      id,
-      version: nextVersion,
-      savedOn: new Date().toISOString(),
-      createdOn: new Date().toISOString(),
-      createdBy: {
-        id: identity.id,
-        displayName: identity.displayName,
-        type: identity.type
-      },
-      modifiedBy: null,
-      locked: false,
-      publishedOn: undefined,
-      status: STATUS_DRAFT,
-      values
-    });
-    let storageEntry = null;
-    try {
-      await onEntryBeforeCreateRevision.publish({
-        input,
-        entry,
-        original: originalEntry,
-        model
-      });
-      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-      const result = await storageOperations.entries.createRevisionFrom(model, {
-        entry,
-        storageEntry
-      });
-      await onEntryRevisionAfterCreate.publish({
-        input,
-        entry,
-        model,
-        original: originalEntry,
-        storageEntry: result
-      });
-      return result;
-    } catch (ex) {
-      await onEntryCreateRevisionError.publish({
-        entry,
-        original: originalEntry,
-        model,
-        input,
-        error: ex
-      });
-      throw new _error.default(ex.message || "Could not create entry from existing one.", ex.code || "CREATE_FROM_REVISION_ERROR", {
-        error: ex,
-        entry,
-        storageEntry,
-        originalEntry,
-        originalStorageEntry
-      });
-    }
-  };
-  const updateEntry = async (model, id, inputData, metaInput) => {
-    const permission = await checkEntryPermissions({
-      rwd: "w"
-    });
-    await (0, _access.checkModelAccess)(context, model);
-
-    /**
-     * Make sure we only work with fields that are defined in the model.
-     */
-    const input = mapAndCleanUpdatedInputData(model, inputData);
-
-    /**
-     * The entry we are going to update.
-     */
-    const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
-      id
-    });
-    if (!originalStorageEntry) {
-      throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
-    }
-    if (originalStorageEntry.locked) {
-      throw new _error.default(`Cannot update entry because it's locked.`, "CONTENT_ENTRY_UPDATE_ERROR");
-    }
-    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-    await (0, _entryDataValidation.validateModelEntryData)({
-      context,
-      model,
-      data: input,
-      entry: originalEntry
-    });
-    (0, _ownership.checkOwnership)(context, permission, originalEntry);
-    const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
-    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-      context,
-      model,
-      input: initialValues,
-      validateEntries: false
-    });
-    /**
-     * If users wants to remove a key from meta values, they need to send meta key with the null value.
-     */
-    const meta = createEntryMeta(metaInput, originalEntry.meta);
-    /**
-     * We always send the full entry to the hooks and storage operations update.
-     */
-    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-      savedOn: new Date().toISOString(),
-      modifiedBy: getCreatedBy(),
-      values,
-      meta,
-      status: transformEntryStatus(originalEntry.status)
-    });
-    let storageEntry = null;
-    try {
-      await onEntryBeforeUpdate.publish({
-        entry,
-        model,
-        input,
-        original: originalEntry
-      });
-      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-      const result = await storageOperations.entries.update(model, {
-        entry,
-        storageEntry
-      });
-      await onEntryAfterUpdate.publish({
-        entry,
-        storageEntry: result,
-        model,
-        input,
-        original: originalEntry
-      });
-      return result;
-    } catch (ex) {
-      await onEntryUpdateError.publish({
-        entry,
-        model,
-        input,
-        error: ex
-      });
-      throw new _error.default(ex.message || "Could not update existing entry.", ex.code || "UPDATE_ERROR", {
-        error: ex,
-        entry,
-        storageEntry,
-        originalEntry,
-        input
-      });
-    }
-  };
-  const republishEntry = async (model, id) => {
-    await checkEntryPermissions({
-      rwd: "w"
-    });
-    await (0, _access.checkModelAccess)(context, 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);
-    /**
-     * We can only process published entries.
-     */
-    if (originalEntry.status !== "published") {
-      throw new _error.default("Entry with given ID is not published!", "NOT_PUBLISHED_ERROR", {
-        id,
-        original: originalEntry
-      });
-    }
-    const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
-      context,
-      model,
-      input: originalEntry.values,
-      validateEntries: false
-    });
-    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-      savedOn: new Date().toISOString(),
-      webinyVersion: context.WEBINY_VERSION,
-      values
-    });
-    const storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-    /**
-     * First we need to update existing entry.
-     */
-    try {
-      await storageOperations.entries.update(model, {
-        entry,
-        storageEntry
-      });
-    } catch (ex) {
-      throw new _error.default("Could not update existing entry with new data while re-publishing.", "REPUBLISH_UPDATE_ERROR", {
-        entry
-      });
-    }
-    /**
-     * Then we move onto publishing it again.
-     */
-    try {
-      await onEntryBeforeRepublish.publish({
-        entry,
-        model
-      });
-      const result = await storageOperations.entries.publish(model, {
-        entry,
-        storageEntry
-      });
-      await onEntryAfterRepublish.publish({
-        entry,
-        model,
-        storageEntry
-      });
-      return result;
-    } catch (ex) {
-      await onEntryRepublishError.publish({
-        entry,
-        model,
-        error: ex
-      });
-      throw new _error.default("Could not publish existing entry while re-publishing.", "REPUBLISH_PUBLISH_ERROR", {
-        entry
-      });
-    }
-  };
-  const deleteEntryRevision = async (model, revisionId) => {
-    const permission = await checkEntryPermissions({
-      rwd: "d"
-    });
-    await (0, _access.checkModelAccess)(context, 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 previousStorageEntry = await storageOperations.entries.getPreviousRevision(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);
-    /**
-     * If targeted record is the latest entry record and there is no previous one, we need to run full delete with hooks.
-     * At this point deleteRevision hooks are not fired.
-     */
-    if (entryToDelete.id === latestEntryRevisionId && !previousStorageEntry) {
-      return await deleteEntryHelper({
-        model,
-        entry: entryToDelete
-      });
-    }
-    /**
-     * If targeted record is latest entry revision, set the previous one as the new latest
-     */
-    let entryToSetAsLatest = null;
-    let storageEntryToSetAsLatest = null;
-    if (entryToDelete.id === latestEntryRevisionId && previousStorageEntry) {
-      entryToSetAsLatest = await (0, _entryStorage.entryFromStorageTransform)(context, model, previousStorageEntry);
-      storageEntryToSetAsLatest = previousStorageEntry;
-    }
-    try {
-      await onEntryRevisionBeforeDelete.publish({
-        entry: entryToDelete,
-        model
-      });
-      await storageOperations.entries.deleteRevision(model, {
-        entry: entryToDelete,
-        storageEntry: storageEntryToDelete,
-        latestEntry: entryToSetAsLatest,
-        latestStorageEntry: storageEntryToSetAsLatest
-      });
-      await onEntryRevisionAfterDelete.publish({
-        entry: entryToDelete,
-        model
-      });
-    } catch (ex) {
-      await onEntryRevisionDeleteError.publish({
-        entry: entryToDelete,
-        model,
-        error: ex
-      });
-      throw new _error.default(ex.message, ex.code || "DELETE_REVISION_ERROR", {
-        error: ex,
-        entry: entryToDelete,
-        storageEntry: storageEntryToDelete,
-        latestEntry: entryToSetAsLatest,
-        latestStorageEntry: storageEntryToSetAsLatest
-      });
-    }
-  };
-  const deleteEntry = async (model, entryId) => {
-    const permission = await checkEntryPermissions({
-      rwd: "d"
-    });
-    await (0, _access.checkModelAccess)(context, model);
-    const storageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
-      id: entryId
-    });
-    if (!storageEntry) {
-      throw new _handlerGraphql.NotFoundError(`Entry "${entryId}" was not found!`);
-    }
-    (0, _ownership.checkOwnership)(context, permission, storageEntry);
-    const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntry);
-    return await deleteEntryHelper({
-      model,
-      entry
-    });
-  };
-  const publishEntry = async (model, id) => {
-    const permission = await checkEntryPermissions({
-      pw: "p"
-    });
-    await (0, _access.checkModelAccess)(context, 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.`);
-    }
-    (0, _ownership.checkOwnership)(context, permission, originalStorageEntry);
-    const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-    const currentDate = new Date().toISOString();
-    const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
-      status: STATUS_PUBLISHED,
-      locked: true,
-      savedOn: currentDate,
-      publishedOn: currentDate
-    });
-    let storageEntry = null;
-    try {
-      await onEntryBeforePublish.publish({
-        entry,
-        model
-      });
-      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-      const result = await storageOperations.entries.publish(model, {
-        entry,
-        storageEntry
-      });
-      await onEntryAfterPublish.publish({
-        entry,
-        storageEntry: result,
-        model
-      });
-      return result;
-    } catch (ex) {
-      await onEntryPublishError.publish({
-        entry,
-        model,
-        error: ex
-      });
-      throw new _error.default(ex.message || "Could not publish entry.", ex.code || "PUBLISH_ERROR", {
-        error: ex,
-        entry,
-        storageEntry,
-        originalEntry,
-        originalStorageEntry
-      });
-    }
-  };
-  const unpublishEntry = async (model, id) => {
-    const permission = await checkEntryPermissions({
-      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
-      });
-    }
-    (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
-    });
-    let storageEntry = null;
-    try {
-      await onEntryBeforeUnpublish.publish({
-        entry,
-        model
-      });
-      storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-      const result = await storageOperations.entries.unpublish(model, {
-        entry,
-        storageEntry
-      });
-      await onEntryAfterUnpublish.publish({
-        entry,
-        storageEntry: result,
-        model
-      });
-      return result;
-    } catch (ex) {
-      await onEntryUnpublishError.publish({
-        entry,
-        model,
-        error: ex
-      });
-      throw new _error.default(ex.message || "Could not unpublish entry.", ex.code || "UNPUBLISH_ERROR", {
-        originalEntry,
-        originalStorageEntry,
-        entry,
-        storageEntry
-      });
-    }
-  };
-  return {
-    /**
-     * Deprecated - will be removed in 5.35.0
-     */
-    onBeforeEntryCreate: onEntryBeforeCreate,
-    onAfterEntryCreate: onEntryAfterCreate,
-    onBeforeEntryCreateRevision: onEntryBeforeCreateRevision,
-    onAfterEntryCreateRevision: onEntryRevisionAfterCreate,
-    onBeforeEntryUpdate: onEntryBeforeUpdate,
-    onAfterEntryUpdate: onEntryAfterUpdate,
-    onBeforeEntryDelete: onEntryBeforeDelete,
-    onAfterEntryDelete: onEntryAfterDelete,
-    onBeforeEntryDeleteRevision: onEntryRevisionBeforeDelete,
-    onAfterEntryDeleteRevision: onEntryRevisionAfterDelete,
-    onBeforeEntryPublish: onEntryBeforePublish,
-    onAfterEntryPublish: onEntryAfterPublish,
-    onBeforeEntryUnpublish: onEntryBeforeUnpublish,
-    onAfterEntryUnpublish: onEntryAfterUnpublish,
-    onBeforeEntryGet: onEntryBeforeGet,
-    onBeforeEntryList: onEntryBeforeList,
-    /**
-     * Released in 5.34.0
-     *
-     * Create
-     */
-    onEntryBeforeCreate,
-    onEntryAfterCreate,
-    onEntryCreateError,
-    /**
-     * Create revision
-     */
-    onEntryRevisionBeforeCreate: onEntryBeforeCreateRevision,
-    onEntryRevisionAfterCreate,
-    onEntryRevisionCreateError: onEntryCreateRevisionError,
-    /**
-     * Update
-     */
-    onEntryBeforeUpdate,
-    onEntryAfterUpdate,
-    onEntryUpdateError,
-    /**
-     * Delete whole entry
-     */
-    onEntryBeforeDelete,
-    onEntryAfterDelete,
-    onEntryDeleteError,
-    /**
-     * Delete entry revision
-     */
-    onEntryRevisionBeforeDelete,
-    onEntryRevisionAfterDelete,
-    onEntryRevisionDeleteError,
-    /**
-     * Publish
-     */
-    onEntryBeforePublish,
-    onEntryAfterPublish,
-    onEntryPublishError,
-    /**
-     * Republish
-     */
-    onEntryBeforeRepublish,
-    onEntryAfterRepublish,
-    onEntryRepublishError,
-    /**
-     * Unpublish
-     */
-    onEntryBeforeUnpublish,
-    onEntryAfterUnpublish,
-    onEntryUnpublishError,
-    onEntryBeforeGet,
-    onEntryBeforeList,
-    /**
-     * Get entries by exact revision IDs from the database.
-     */
-    getEntriesByIds,
-    /**
-     * Get a single entry by revision ID from the database.
-     */
-    async getEntryById(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.getEntryById", async () => {
-        return getEntryById(model, id);
-      });
-    },
-    /**
-     * Get published revisions by entry IDs.
-     */
-    async getPublishedEntriesByIds(model, ids) {
-      return context.benchmark.measure("headlessCms.crud.entries.getPublishedEntriesByIds", async () => {
-        return getPublishedEntriesByIds(model, ids);
-      });
-    },
-    /**
-     * Get the latest revisions by entry IDs.
-     */
-    async getLatestEntriesByIds(model, ids) {
-      return context.benchmark.measure("headlessCms.crud.entries.getLatestEntriesByIds", async () => {
-        return getLatestEntriesByIds(model, ids);
-      });
-    },
-    async getEntryRevisions(model, entryId) {
-      return context.benchmark.measure("headlessCms.crud.entries.getEntryRevisions", async () => {
-        return getEntryRevisions(model, entryId);
-      });
-    },
-    /**
-     * TODO determine if this method is required at all.
-     *
-     * @internal
-     */
-    async getEntry(model, params) {
-      return context.benchmark.measure("headlessCms.crud.entries.getEntry", async () => {
-        return getEntry(model, params);
-      });
-    },
-    /**
-     * @description Should not be used directly. Internal use only!
-     *
-     * @internal
-     */
-    async listEntries(model, params) {
-      return context.benchmark.measure("headlessCms.crud.entries.listEntries", async () => {
-        return listEntries(model, params);
-      });
-    },
-    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
-        })
-      }));
-    },
-    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
-        })
-      }));
-    },
-    async createEntry(model, input) {
-      return context.benchmark.measure("headlessCms.crud.entries.createEntry", async () => {
-        return createEntry(model, input);
-      });
-    },
-    async createEntryRevisionFrom(model, sourceId, input) {
-      return context.benchmark.measure("headlessCms.crud.entries.createEntryRevisionFrom", async () => {
-        return createEntryRevisionFrom(model, sourceId, input);
-      });
-    },
-    async updateEntry(model, id, input, meta) {
-      return context.benchmark.measure("headlessCms.crud.entries.updateEntry", async () => {
-        return updateEntry(model, id, input, meta);
-      });
-    },
-    /**
-     * Method used internally. Not documented and should not be used in users systems.
-     * @internal
-     */
-    async republishEntry(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.republishEntry", async () => {
-        return republishEntry(model, id);
-      });
-    },
-    async deleteEntryRevision(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.deleteEntryRevision", async () => {
-        return deleteEntryRevision(model, id);
-      });
-    },
-    async deleteEntry(model, entryId) {
-      return context.benchmark.measure("headlessCms.crud.entries.deleteEntry", async () => {
-        return deleteEntry(model, entryId);
-      });
-    },
-    async publishEntry(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.publishEntry", async () => {
-        return publishEntry(model, id);
-      });
-    },
-    async unpublishEntry(model, id) {
-      return context.benchmark.measure("headlessCms.crud.entries.unpublishEntry", async () => {
-        return unpublishEntry(model, id);
-      });
-    }
-  };
 };
-exports.createContentEntryCrud = createContentEntryCrud;
+export { createContentEntryCrud };
+
+//# sourceMappingURL=contentEntry.crud.js.map