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

package/content/plugins/crud/contentEntry.crud.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.STATUS_UNPUBLISHED = exports.STATUS_REVIEW_REQUESTED = exports.STATUS_PUBLISHED = exports.STATUS_DRAFT = exports.STATUS_CHANGES_REQUESTED = void 0;
+exports.createContentEntryCrud = exports.STATUS_UNPUBLISHED = exports.STATUS_REVIEW_REQUESTED = exports.STATUS_PUBLISHED = exports.STATUS_DRAFT = exports.STATUS_CHANGES_REQUESTED = void 0;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
@@ -17,10 +17,16 @@ var utils = _interopRequireWildcard(require("../../../utils"));
 
 var _entryDataValidation = require("./contentEntry/entryDataValidation");
 
-var _hooks = require("./contentEntry/hooks");
-
 var _error = _interopRequireDefault(require("@webiny/error"));
 
+var _pubsub = require("@webiny/pubsub");
+
+var _beforeCreate = require("./contentEntry/beforeCreate");
+
+var _beforeUpdate = require("./contentEntry/beforeUpdate");
+
+var _utils2 = require("@webiny/utils");
+
 var _entryStorage = require("../utils/entryStorage");
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
@@ -65,7 +71,10 @@ const createEntryId = version => {
   return {
     entryId,
     version,
-    id: `${entryId}#${utils.zeroPad(version)}`
+    id: (0, _utils2.createIdentifier)({
+      id: entryId,
+      version
+    })
   };
 };
 
@@ -81,829 +90,870 @@ const increaseEntryIdVersion = id => {
   return {
     entryId,
     version: ver,
-    id: `${entryId}#${utils.zeroPad(ver)}`
+    id: (0, _utils2.createIdentifier)({
+      id: entryId,
+      version: ver
+    })
   };
 };
 
-var _default = () => ({
-  type: "context",
-  name: "context-content-model-entry",
+const createContentEntryCrud = params => {
+  const {
+    storageOperations,
+    context,
+    getTenant,
+    getLocale,
+    getIdentity
+  } = params;
+  const onBeforeCreate = (0, _pubsub.createTopic)();
+  const onAfterCreate = (0, _pubsub.createTopic)();
+  const onBeforeCreateRevision = (0, _pubsub.createTopic)();
+  const onAfterCreateRevision = (0, _pubsub.createTopic)();
+  const onBeforeUpdate = (0, _pubsub.createTopic)();
+  const onAfterUpdate = (0, _pubsub.createTopic)();
+  const onBeforePublish = (0, _pubsub.createTopic)();
+  const onAfterPublish = (0, _pubsub.createTopic)();
+  const onBeforeUnpublish = (0, _pubsub.createTopic)();
+  const onAfterUnpublish = (0, _pubsub.createTopic)();
+  const onBeforeRequestChanges = (0, _pubsub.createTopic)();
+  const onAfterRequestChanges = (0, _pubsub.createTopic)();
+  const onBeforeRequestReview = (0, _pubsub.createTopic)();
+  const onAfterRequestReview = (0, _pubsub.createTopic)();
+  const onBeforeDelete = (0, _pubsub.createTopic)();
+  const onAfterDelete = (0, _pubsub.createTopic)();
+  const onBeforeDeleteRevision = (0, _pubsub.createTopic)();
+  const onAfterDeleteRevision = (0, _pubsub.createTopic)();
+  const onBeforeGet = (0, _pubsub.createTopic)();
+  const onBeforeList = (0, _pubsub.createTopic)();
+  /**
+   * We need to assign some default behaviors.
+   */
+
+  (0, _beforeCreate.assignBeforeEntryCreate)({
+    context,
+    onBeforeCreate
+  });
+  (0, _beforeUpdate.assignBeforeEntryUpdate)({
+    context,
+    onBeforeUpdate
+  });
+
+  const checkEntryPermissions = check => {
+    return utils.checkPermissions(context, "cms.contentEntry", check);
+  };
+  /**
+   * A helper to delete the entire entry.
+   */
+
+
+  const deleteEntry = async params => {
+    const {
+      model,
+      entry,
+      storageEntry
+    } = params;
+
+    try {
+      await onBeforeDelete.publish({
+        entry,
+        model
+      });
+      await storageOperations.entries.delete(model, {
+        entry,
+        storageEntry
+      });
+      await onAfterDelete.publish({
+        entry,
+        model
+      });
+    } catch (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) => {
+    const permission = await checkEntryPermissions({
+      rwd: "r"
+    });
+    await utils.checkModelAccess(context, model);
+    const entries = await storageOperations.entries.getByIds(model, {
+      tenant: getTenant().id,
+      locale: getLocale().code,
+      ids
+    });
+    return entries.filter(entry => utils.validateOwnership(context, permission, entry));
+  };
+
+  return {
+    onBeforeEntryCreate: onBeforeCreate,
+    onAfterEntryCreate: onAfterCreate,
+    onBeforeEntryRevisionCreate: onBeforeCreateRevision,
+    onAfterEntryRevisionCreate: onAfterCreateRevision,
+    onBeforeEntryUpdate: onBeforeUpdate,
+    onAfterEntryUpdate: onAfterUpdate,
+    onBeforeEntryDelete: onBeforeDelete,
+    onAfterEntryDelete: onAfterDelete,
+    onBeforeEntryRevisionDelete: onBeforeDeleteRevision,
+    onAfterEntryRevisionDelete: onAfterDeleteRevision,
+    onBeforeEntryPublish: onBeforePublish,
+    onAfterEntryPublish: onAfterPublish,
+    onBeforeEntryUnpublish: onBeforeUnpublish,
+    onAfterEntryUnpublish: onAfterUnpublish,
+    onBeforeEntryRequestChanges: onBeforeRequestChanges,
+    onAfterEntryRequestChanges: onAfterRequestChanges,
+    onBeforeEntryRequestReview: onBeforeRequestReview,
+    onAfterEntryRequestReview: onAfterRequestReview,
+    onBeforeEntryGet: onBeforeGet,
+    onBeforeEntryList: onBeforeList,
 
-  async apply(context) {
     /**
-     * If cms is not defined on the context, do not continue, but log it.
+     * Get entries by exact revision IDs from the database.
      */
-    if (!context.cms) {
-      return;
-    }
+    getEntriesByIds: getEntriesByIds,
 
-    const pluginType = "cms-content-entry-storage-operations-provider";
-    const providerPlugins = context.plugins.byType(pluginType);
     /**
-     * Storage operations for the content entry.
-     * Contains logic to save the data into the specific storage.
+     * Get a single entry by revision ID from the database.
      */
+    getEntryById: async (model, id) => {
+      const where = {
+        id
+      };
+      await onBeforeGet.publish({
+        where,
+        model
+      });
+      const [entry] = await getEntriesByIds(model, [where.id]);
 
-    const providerPlugin = providerPlugins[providerPlugins.length - 1];
+      if (!entry) {
+        throw new _handlerGraphql.NotFoundError(`Entry by ID "${id}" not found.`);
+      }
 
-    if (!providerPlugin) {
-      throw new _error.default(`Missing "${pluginType}" plugin.`, "PLUGIN_NOT_FOUND", {
-        type: pluginType
-      });
-    }
+      return entry;
+    },
 
-    const storageOperations = await providerPlugin.provide({
-      context
-    });
+    /**
+     * Get published revisions by entry IDs.
+     */
+    getPublishedEntriesByIds: async (model, ids) => {
+      const permission = await checkEntryPermissions({
+        rwd: "r"
+      });
+      await utils.checkModelAccess(context, model);
+      const entries = await storageOperations.entries.getPublishedByIds(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        ids
+      });
+      return entries.filter(entry => utils.validateOwnership(context, permission, entry));
+    },
 
-    const checkEntryPermissions = check => {
-      return utils.checkPermissions(context, "cms.contentEntry", check);
-    };
     /**
-     * A helper to delete the entire entry.
+     * Get latest revisions by entry IDs.
      */
+    getLatestEntriesByIds: async (model, ids) => {
+      const permission = await checkEntryPermissions({
+        rwd: "r"
+      });
+      await utils.checkModelAccess(context, model);
+      const entries = await storageOperations.entries.getLatestByIds(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        ids
+      });
+      return entries.filter(entry => utils.validateOwnership(context, permission, entry));
+    },
+    getEntryRevisions: async (model, entryId) => {
+      return storageOperations.entries.getRevisions(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id: entryId
+      });
+    },
+    getEntry: async (model, params) => {
+      await checkEntryPermissions({
+        rwd: "r"
+      });
+      const {
+        where,
+        sort
+      } = params;
+      await onBeforeGet.publish({
+        where,
+        model
+      });
+      const [items] = await context.cms.listEntries(model, {
+        where,
+        sort,
+        limit: 1
+      });
 
+      if (items.length === 0) {
+        throw new _handlerGraphql.NotFoundError(`Entry not found!`);
+      }
 
-    const deleteEntry = async params => {
+      return items[0];
+    },
+    listEntries: async (model, params) => {
+      const permission = await checkEntryPermissions({
+        rwd: "r"
+      });
+      await utils.checkModelAccess(context, model);
+      const where = params.where || {};
+      /**
+       * 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;
+
+      const listWhere = _objectSpread(_objectSpread({}, where), {}, {
+        tenant: where.tenant || getTenant().id,
+        locale: where.locale || getLocale().code
+      });
+
+      if (ownedBy !== undefined) {
+        listWhere.ownedBy = ownedBy;
+      }
+
+      await onBeforeList.publish({
+        where: listWhere,
+        model
+      });
       const {
-        model,
-        entry,
-        storageEntry
-      } = params;
+        hasMoreItems,
+        totalCount,
+        cursor,
+        items
+      } = await storageOperations.entries.list(model, _objectSpread(_objectSpread({}, params), {}, {
+        where: listWhere
+      }));
+      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];
+    },
+    listLatestEntries: async function (model, params) {
+      const where = params ? params.where : {};
+      return context.cms.listEntries(model, _objectSpread(_objectSpread({
+        sort: ["createdOn_DESC"]
+      }, params || {}), {}, {
+        where: _objectSpread(_objectSpread({}, where), {}, {
+          latest: true
+        })
+      }));
+    },
+    listPublishedEntries: async function (model, params) {
+      const where = params ? params.where : {};
+      return context.cms.listEntries(model, _objectSpread(_objectSpread({
+        sort: ["createdOn_DESC"]
+      }, params || {}), {}, {
+        where: _objectSpread(_objectSpread({}, where), {}, {
+          published: true
+        })
+      }));
+    },
+    createEntry: async (model, inputData) => {
+      await checkEntryPermissions({
+        rwd: "w"
+      });
+      await utils.checkModelAccess(context, model);
+      /**
+       * Make sure we only work with fields that are defined in the model.
+       */
+
+      const input = cleanInputData(model, inputData);
+      await (0, _entryDataValidation.validateModelEntryData)(context, model, input);
+      const identity = context.security.getIdentity();
+      const locale = context.cms.getLocale();
+      const owner = {
+        id: identity.id,
+        displayName: identity.displayName,
+        type: identity.type
+      };
+      const {
+        id,
+        entryId,
+        version
+      } = createEntryId(1);
+      const entry = {
+        webinyVersion: context.WEBINY_VERSION,
+        tenant: context.tenancy.getCurrentTenant().id,
+        entryId,
+        id,
+        modelId: model.modelId,
+        locale: locale.code,
+        createdOn: new Date().toISOString(),
+        savedOn: new Date().toISOString(),
+        createdBy: owner,
+        ownedBy: owner,
+        version,
+        locked: false,
+        status: STATUS_DRAFT,
+        values: input
+      };
+      let storageEntry = null;
 
       try {
-        await (0, _hooks.beforeDeleteHook)({
-          context,
-          model,
+        await onBeforeCreate.publish({
           entry,
-          storageEntry,
-          storageOperations
+          input,
+          model
         });
-        await storageOperations.delete(model, {
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.create(model, {
+          input,
           entry,
           storageEntry
         });
-        await (0, _hooks.afterDeleteHook)({
-          context,
-          model,
+        await onAfterCreate.publish({
           entry,
-          storageEntry,
-          storageOperations
+          storageEntry: result,
+          model,
+          input
         });
+        return result;
       } catch (ex) {
-        throw new _error.default(ex.message || "Could not delete entry.", ex.code || "DELETE_ERROR", {
-          entry
+        throw new _error.default(ex.message || "Could not create content entry.", ex.code || "CREATE_ENTRY_ERROR", ex.data || {
+          error: ex,
+          input,
+          entry,
+          storageEntry
         });
       }
-    };
-    /**
-     * A helper to get entries by revision IDs
-     */
+    },
+    createEntryRevisionFrom: async (model, sourceId, inputData = {}) => {
+      const permission = await checkEntryPermissions({
+        rwd: "w"
+      });
+      await utils.checkModelAccess(context, model);
+      /**
+       * Make sure we only work with fields that are defined in the model.
+       */
 
+      const input = cleanUpdatedInputData(model, inputData);
+      /**
+       * Entries are identified by a common parent ID + Revision number.
+       */
 
-    const getEntriesByIds = async (model, ids) => {
+      const [uniqueId] = sourceId.split("#");
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id: sourceId
+      });
+      const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        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 values = _objectSpread(_objectSpread({}, originalEntry.values), input);
+
+      await (0, _entryDataValidation.validateModelEntryData)(context, model, values);
+      utils.checkOwnership(context, permission, originalEntry);
+      const latestEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, latestStorageEntry);
+      const identity = context.security.getIdentity();
+      const latestId = latestStorageEntry ? latestStorageEntry.id : sourceId;
+      const {
+        id,
+        version: nextVersion
+      } = increaseEntryIdVersion(latestId);
+
+      const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
+        id,
+        version: nextVersion,
+        savedOn: new Date().toISOString(),
+        createdOn: new Date().toISOString(),
+        createdBy: {
+          id: identity.id,
+          displayName: identity.displayName,
+          type: identity.type
+        },
+        locked: false,
+        publishedOn: null,
+        status: STATUS_DRAFT,
+        values
+      });
+
+      let storageEntry = undefined;
+
+      try {
+        await onBeforeCreateRevision.publish({
+          entry,
+          model
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.createRevisionFrom(model, {
+          entry,
+          storageEntry,
+          originalEntry,
+          originalStorageEntry,
+          latestEntry,
+          latestStorageEntry
+        });
+        await onAfterCreateRevision.publish({
+          entry,
+          model,
+          storageEntry: result
+        });
+        return result;
+      } catch (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
+        });
+      }
+    },
+    updateEntry: async (model, id, inputData) => {
       const permission = await checkEntryPermissions({
-        rwd: "r"
+        rwd: "w"
       });
       await utils.checkModelAccess(context, model);
-      const entries = await storageOperations.getByIds(model, ids);
-      return entries.filter(entry => utils.validateOwnership(context, permission, entry));
-    };
-
-    const entries = {
-      operations: storageOperations,
+      /**
+       * Make sure we only work with fields that are defined in the model.
+       */
 
+      const input = cleanInputData(model, inputData);
       /**
-       * Get entries by exact revision IDs from the database.
+       * Validate data early. We don't want to query DB if input data is invalid.
        */
-      getByIds: getEntriesByIds,
 
+      await (0, _entryDataValidation.validateModelEntryData)(context, model, input);
       /**
-       * Get a single entry by revision ID from the database.
+       * The entry we are going to update.
        */
-      getById: async (model, id) => {
-        const [entry] = await getEntriesByIds(model, [id]);
 
-        if (!entry) {
-          throw new _handlerGraphql.NotFoundError(`Entry by ID "${id}" not found.`);
-        }
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id
+      });
+
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
+      }
 
-        return entry;
-      },
+      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);
+      utils.checkOwnership(context, permission, originalEntry);
       /**
-       * Get latest published revisions by entry IDs.
+       * We always send the full entry to the hooks and storage operations update.
        */
-      getPublishedByIds: async (model, ids) => {
-        const permission = await checkEntryPermissions({
-          rwd: "r"
+
+      const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
+        savedOn: new Date().toISOString(),
+        values: _objectSpread(_objectSpread({}, originalEntry.values), input)
+      });
+
+      let storageEntry = undefined;
+
+      try {
+        await onBeforeUpdate.publish({
+          entry,
+          model,
+          input,
+          original: originalEntry
         });
-        await utils.checkModelAccess(context, model);
-        const entries = await storageOperations.getPublishedByIds(model, ids);
-        return entries.filter(entry => utils.validateOwnership(context, permission, entry));
-      },
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.update(model, {
+          originalEntry,
+          originalStorageEntry,
+          entry,
+          storageEntry,
+          input
+        });
+        await onAfterUpdate.publish({
+          entry,
+          storageEntry: result,
+          model,
+          input,
+          original: originalEntry
+        });
+        return result;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not update existing entry.", ex.code || "UPDATE_ERROR", {
+          error: ex,
+          entry,
+          storageEntry,
+          originalEntry,
+          input
+        });
+      }
+    },
+    deleteEntryRevision: async (model, revisionId) => {
+      const permission = await checkEntryPermissions({
+        rwd: "d"
+      });
+      await utils.checkModelAccess(context, model);
+      const {
+        id: entryId,
+        version
+      } = (0, _utils2.parseIdentifier)(revisionId);
+      const storageEntryToDelete = await storageOperations.entries.getRevisionById(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id: revisionId
+      });
+      const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id: entryId
+      });
+      const previousStorageEntry = await storageOperations.entries.getPreviousRevision(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        entryId,
+        version
+      });
 
+      if (!storageEntryToDelete) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${revisionId}" was not found!`);
+      }
+
+      utils.checkOwnership(context, permission, storageEntryToDelete);
+      const latestEntryRevisionId = latestStorageEntry ? latestStorageEntry.id : null;
+      const entryToDelete = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntryToDelete);
       /**
-       * Get latest revisions by entry IDs.
+       * 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.
        */
-      getLatestByIds: async (model, ids) => {
-        const permission = await checkEntryPermissions({
-          rwd: "r"
-        });
-        await utils.checkModelAccess(context, model);
-        const entries = await storageOperations.getLatestByIds(model, ids);
-        return entries.filter(entry => utils.validateOwnership(context, permission, entry));
-      },
-      getEntryRevisions: async (model, entryId) => {
-        return storageOperations.getRevisions(model, entryId);
-      },
-      get: async (model, args) => {
-        await checkEntryPermissions({
-          rwd: "r"
-        });
-        const [items] = await context.cms.entries.list(model, _objectSpread(_objectSpread({}, args), {}, {
-          limit: 1
-        }));
-
-        if (items.length === 0) {
-          throw new _handlerGraphql.NotFoundError(`Entry not found!`);
-        }
-
-        return items[0];
-      },
-      list: async (model, args) => {
-        const permission = await checkEntryPermissions({
-          rwd: "r"
-        });
-        await utils.checkModelAccess(context, model);
-        const {
-          where = {}
-        } = args || {};
-        /**
-         * 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 ? context.security.getIdentity().id : where.ownedBy;
-
-        const listWhere = _objectSpread({}, where);
-
-        if (ownedBy !== undefined) {
-          listWhere.ownedBy = ownedBy;
-        }
-
-        const {
-          hasMoreItems,
-          totalCount,
-          cursor,
-          items
-        } = await storageOperations.list(model, _objectSpread(_objectSpread({}, args), {}, {
-          where: listWhere
-        }));
-        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.list method.
-           */
-          cursor: hasMoreItems ? cursor : null
-        };
-        return [items, meta];
-      },
-      listLatest: async function (model, args = {}) {
-        return context.cms.entries.list(model, _objectSpread(_objectSpread({
-          sort: ["createdOn_DESC"]
-        }, args), {}, {
-          where: _objectSpread(_objectSpread({}, args.where || {}), {}, {
-            latest: true
-          })
-        }));
-      },
-      listPublished: async function (model, args = {}) {
-        return context.cms.entries.list(model, _objectSpread(_objectSpread({
-          sort: ["createdOn_DESC"]
-        }, args), {}, {
-          where: _objectSpread(_objectSpread({}, args.where || {}), {}, {
-            published: true
-          })
-        }));
-      },
-      create: async (model, inputData) => {
-        await checkEntryPermissions({
-          rwd: "w"
-        });
-        await utils.checkModelAccess(context, model);
-        /**
-         * Make sure we only work with fields that are defined in the model.
-         */
+      if (entryToDelete.id === latestEntryRevisionId && !previousStorageEntry) {
+        return await deleteEntry({
+          model,
+          entry: entryToDelete,
+          storageEntry: storageEntryToDelete
+        });
+      }
+      /**
+       * If targeted record is latest entry revision, set the previous one as the new latest
+       */
 
-        const input = cleanInputData(model, inputData);
-        await (0, _entryDataValidation.validateModelEntryData)(context, model, input);
-        const identity = context.security.getIdentity();
-        const locale = context.cms.getLocale();
-        const owner = {
-          id: identity.id,
-          displayName: identity.displayName,
-          type: identity.type
-        };
-        const {
-          id,
-          entryId,
-          version
-        } = createEntryId(1);
-        const entry = {
-          webinyVersion: context.WEBINY_VERSION,
-          tenant: context.tenancy.getCurrentTenant().id,
-          entryId,
-          id,
-          modelId: model.modelId,
-          locale: locale.code,
-          createdOn: new Date().toISOString(),
-          savedOn: new Date().toISOString(),
-          createdBy: owner,
-          ownedBy: owner,
-          version,
-          locked: false,
-          status: STATUS_DRAFT,
-          values: input
-        };
-        let storageEntry = null;
-
-        try {
-          await (0, _hooks.beforeCreateHook)({
-            model,
-            input,
-            entry,
-            context,
-            storageOperations
-          });
-          storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-          const result = await storageOperations.create(model, {
-            input,
-            entry,
-            storageEntry
-          });
-          await (0, _hooks.afterCreateHook)({
-            model,
-            input,
-            entry,
-
-            /**
-             * Pass the result because storage operations might have changed something (saved date, etc...)
-             */
-            storageEntry: result,
-            context,
-            storageOperations
-          });
-          return result;
-        } catch (ex) {
-          throw new _error.default(ex.message || "Could not create content entry.", ex.code || "CREATE_ENTRY_ERROR", ex.data || {
-            error: ex,
-            input,
-            entry,
-            storageEntry
-          });
-        }
-      },
-      createRevisionFrom: async (model, sourceId, inputData = {}) => {
-        const permission = await checkEntryPermissions({
-          rwd: "w"
-        });
-        await utils.checkModelAccess(context, model);
-        /**
-         * Make sure we only work with fields that are defined in the model.
-         */
 
-        const input = cleanUpdatedInputData(model, inputData);
-        /**
-         * Entries are identified by a common parent ID + Revision number.
-         */
+      let entryToSetAsLatest = null;
+      let storageEntryToSetAsLatest = null;
 
-        const [uniqueId] = sourceId.split("#");
-        const originalStorageEntry = await storageOperations.getRevisionById(model, sourceId);
-        const latestStorageEntry = await storageOperations.getLatestRevisionByEntryId(model, uniqueId);
+      if (entryToDelete.id === latestEntryRevisionId) {
+        entryToSetAsLatest = await (0, _entryStorage.entryFromStorageTransform)(context, model, previousStorageEntry);
+        storageEntryToSetAsLatest = previousStorageEntry;
+      }
 
-        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.
-         */
+      try {
+        await onBeforeDeleteRevision.publish({
+          entry: entryToDelete,
+          model
+        });
+        await storageOperations.entries.deleteRevision(model, {
+          entryToDelete,
+          storageEntryToDelete,
+          entryToSetAsLatest,
+          storageEntryToSetAsLatest
+        });
+        await onAfterDeleteRevision.publish({
+          entry: entryToDelete,
+          model
+        });
+      } catch (ex) {
+        throw new _error.default(ex.message, ex.code || "DELETE_REVISION_ERROR", {
+          error: ex,
+          entryToDelete,
+          storageEntryToDelete,
+          entryToSetAsLatest,
+          storageEntryToSetAsLatest
+        });
+      }
+    },
+    deleteEntry: async (model, entryId) => {
+      const permission = await checkEntryPermissions({
+        rwd: "d"
+      });
+      await utils.checkModelAccess(context, model);
+      const storageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id: entryId
+      });
 
+      if (!storageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${entryId}" was not found!`);
+      }
 
-        const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-
-        const values = _objectSpread(_objectSpread({}, originalEntry.values), input);
-
-        await (0, _entryDataValidation.validateModelEntryData)(context, model, values);
-        utils.checkOwnership(context, permission, originalEntry);
-        const latestEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, latestStorageEntry);
-        const identity = context.security.getIdentity();
-        const latestId = latestStorageEntry ? latestStorageEntry.id : sourceId;
-        const {
-          id,
-          version: nextVersion
-        } = increaseEntryIdVersion(latestId);
-
-        const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
-          id,
-          version: nextVersion,
-          savedOn: new Date().toISOString(),
-          createdOn: new Date().toISOString(),
-          createdBy: {
-            id: identity.id,
-            displayName: identity.displayName,
-            type: identity.type
-          },
-          locked: false,
-          publishedOn: null,
-          status: STATUS_DRAFT,
-          values
-        });
-
-        let storageEntry = undefined;
-
-        try {
-          await (0, _hooks.beforeCreateRevisionFromHook)({
-            context,
-            model,
-            entry,
-            storageEntry,
-            originalEntry,
-            originalStorageEntry,
-            latestEntry,
-            latestStorageEntry,
-            storageOperations
-          });
-          storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-          const result = await storageOperations.createRevisionFrom(model, {
-            entry,
-            storageEntry,
-            originalEntry,
-            originalStorageEntry,
-            latestEntry,
-            latestStorageEntry
-          });
-          await (0, _hooks.afterCreateRevisionFromHook)({
-            context,
-            model,
-            originalEntry,
-            originalStorageEntry,
-            latestEntry,
-            latestStorageEntry,
-            entry,
-
-            /**
-             * Passing result due to storage operations might have changed something on the entry.
-             */
-            storageEntry: result,
-            storageOperations
-          });
-          return result;
-        } catch (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
-          });
-        }
-      },
-      update: async (model, id, inputData) => {
-        const permission = await checkEntryPermissions({
-          rwd: "w"
-        });
-        await utils.checkModelAccess(context, model);
-        /**
-         * Make sure we only work with fields that are defined in the model.
-         */
+      utils.checkOwnership(context, permission, storageEntry);
+      const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntry);
+      return await deleteEntry({
+        model,
+        entry,
+        storageEntry
+      });
+    },
+    publishEntry: async (model, id) => {
+      const permission = await checkEntryPermissions({
+        pw: "p"
+      });
+      await utils.checkModelAccess(context, model);
+      const tenant = getTenant().id;
+      const locale = getLocale().code;
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        tenant,
+        locale,
+        id
+      });
 
-        const input = cleanInputData(model, inputData);
-        /**
-         * Validate data early. We don't want to query DB if input data is invalid.
-         */
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" in the model "${model.modelId}" was not found.`);
+      }
 
-        await (0, _entryDataValidation.validateModelEntryData)(context, model, input);
-        /**
-         * The entry we are going to update.
-         */
+      utils.checkOwnership(context, permission, originalStorageEntry);
+      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+      const currentDate = new Date().toISOString();
 
-        const originalStorageEntry = await storageOperations.getRevisionById(model, id);
+      const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
+        status: STATUS_PUBLISHED,
+        locked: true,
+        savedOn: currentDate,
+        publishedOn: currentDate
+      });
 
-        if (!originalStorageEntry) {
-          throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
-        }
+      let storageEntry = undefined;
 
-        if (originalStorageEntry.locked) {
-          throw new _error.default(`Cannot update entry because it's locked.`, "CONTENT_ENTRY_UPDATE_ERROR");
-        }
+      try {
+        await onBeforePublish.publish({
+          entry,
+          model
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.publish(model, {
+          entry,
+          storageEntry,
+          originalEntry,
+          originalStorageEntry
+        });
+        await onAfterPublish.publish({
+          entry,
+          storageEntry: result,
+          model
+        });
+        return result;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not publish entry.", ex.code || "PUBLISH_ERROR", {
+          error: ex,
+          entry,
+          storageEntry,
+          originalEntry,
+          originalStorageEntry
+        });
+      }
+    },
+    requestEntryChanges: async (model, id) => {
+      const permission = await checkEntryPermissions({
+        pw: "c"
+      });
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id
+      });
 
-        const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-        utils.checkOwnership(context, permission, originalEntry);
-        /**
-         * We always send the full entry to the hooks and storage operations update.
-         */
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
+      }
 
-        const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
-          savedOn: new Date().toISOString(),
-          values: _objectSpread(_objectSpread({}, originalEntry.values), input)
-        });
-
-        let storageEntry = undefined;
-
-        try {
-          await (0, _hooks.beforeUpdateHook)({
-            context,
-            model,
-            input,
-            entry,
-            originalEntry,
-            originalStorageEntry,
-            storageOperations
-          });
-          storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-          const result = await storageOperations.update(model, {
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry,
-            input
-          });
-          await (0, _hooks.afterUpdateHook)({
-            context,
-            model,
-            input,
-            entry,
-            storageEntry: result,
-            originalEntry,
-            originalStorageEntry,
-            storageOperations
-          });
-          return result;
-        } catch (ex) {
-          throw new _error.default(ex.message || "Could not update existing entry.", ex.code || "UPDATE_ERROR", {
-            error: ex,
-            entry,
-            storageEntry,
-            originalEntry,
-            input
-          });
-        }
-      },
-      deleteRevision: async (model, revisionId) => {
-        const permission = await checkEntryPermissions({
-          rwd: "d"
-        });
-        await utils.checkModelAccess(context, model);
-        const [entryId, version] = revisionId.split("#");
-        const storageEntryToDelete = await storageOperations.getRevisionById(model, revisionId);
-        const latestStorageEntry = await storageOperations.getLatestRevisionByEntryId(model, entryId);
-        const previousStorageEntry = await storageOperations.getPreviousRevision(model, entryId, parseInt(version));
-
-        if (!storageEntryToDelete) {
-          throw new _handlerGraphql.NotFoundError(`Entry "${revisionId}" was not found!`);
-        }
-
-        utils.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 deleteEntry hooks are not fired.
-         * TODO determine if not running the deleteRevision hooks is ok.
-         */
+      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
 
-        if (entryToDelete.id === latestEntryRevisionId && !previousStorageEntry) {
-          return await deleteEntry({
-            model,
-            entry: entryToDelete,
-            storageEntry: storageEntryToDelete
-          });
-        }
-        /**
-         * If targeted record is latest entry revision, set the previous one as the new latest
-         */
+      if (originalEntry.status !== STATUS_REVIEW_REQUESTED) {
+        throw new _error.default("Cannot request changes on an entry that's not under review.", "ENTRY_NOT_UNDER_REVIEW");
+      }
 
+      const identity = context.security.getIdentity();
 
-        let entryToSetAsLatest = null;
-        let storageEntryToSetAsLatest = null;
-
-        if (entryToDelete.id === latestEntryRevisionId) {
-          entryToSetAsLatest = await (0, _entryStorage.entryFromStorageTransform)(context, model, previousStorageEntry);
-          storageEntryToSetAsLatest = previousStorageEntry;
-        }
-
-        try {
-          await (0, _hooks.beforeDeleteRevisionHook)({
-            context,
-            model,
-            storageOperations,
-            entryToDelete,
-            storageEntryToDelete,
-            entryToSetAsLatest,
-            storageEntryToSetAsLatest
-          });
-          await storageOperations.deleteRevision(model, {
-            entryToDelete,
-            storageEntryToDelete,
-            entryToSetAsLatest,
-            storageEntryToSetAsLatest
-          });
-          await (0, _hooks.afterDeleteRevisionHook)({
-            context,
-            model,
-            storageOperations,
-            entryToDelete,
-            storageEntryToDelete,
-            entryToSetAsLatest,
-            storageEntryToSetAsLatest
-          });
-        } catch (ex) {
-          throw new _error.default(ex.message, ex.code || "DELETE_REVISION_ERROR", {
-            error: ex,
-            entryToDelete,
-            storageEntryToDelete,
-            entryToSetAsLatest,
-            storageEntryToSetAsLatest
-          });
-        }
-      },
-      deleteEntry: async (model, entryId) => {
-        const permission = await checkEntryPermissions({
-          rwd: "d"
-        });
-        await utils.checkModelAccess(context, model);
-        const storageEntry = await storageOperations.getLatestRevisionByEntryId(model, entryId);
-
-        if (!storageEntry) {
-          throw new _handlerGraphql.NotFoundError(`Entry "${entryId}" was not found!`);
-        }
-
-        utils.checkOwnership(context, permission, storageEntry);
-        const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntry);
-        return await deleteEntry({
-          model,
+      if (originalEntry.ownedBy.id === identity.id) {
+        throw new _error.default("You cannot request changes on your own entry.", "CANNOT_REQUEST_CHANGES_ON_OWN_ENTRY");
+      }
+
+      utils.checkOwnership(context, permission, originalEntry);
+
+      const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
+        status: STATUS_CHANGES_REQUESTED
+      });
+
+      let storageEntry = undefined;
+
+      try {
+        await onBeforeRequestChanges.publish({
+          entry,
+          model
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.requestChanges(model, {
+          originalEntry,
+          originalStorageEntry,
           entry,
           storageEntry
         });
-      },
-      publish: async (model, id) => {
-        const permission = await checkEntryPermissions({
-          pw: "p"
-        });
-        await utils.checkModelAccess(context, model);
-        const originalStorageEntry = await storageOperations.getRevisionById(model, id);
-
-        if (!originalStorageEntry) {
-          throw new _handlerGraphql.NotFoundError(`Entry "${id}" in the model "${model.modelId}" was not found.`);
-        }
-
-        utils.checkOwnership(context, permission, originalStorageEntry);
-        const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-        const currentDate = new Date().toISOString();
-
-        const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
-          status: STATUS_PUBLISHED,
-          locked: true,
-          savedOn: currentDate,
-          publishedOn: currentDate
-        });
-
-        let storageEntry = undefined;
-
-        try {
-          await (0, _hooks.beforePublishHook)({
-            context,
-            storageOperations,
-            model,
-            entry,
-            originalEntry,
-            originalStorageEntry
-          });
-          storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-          const result = await storageOperations.publish(model, {
-            entry,
-            storageEntry,
-            originalEntry,
-            originalStorageEntry
-          });
-          await (0, _hooks.afterPublishHook)({
-            context,
-            storageOperations,
-            model,
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry: result
-          });
-          return result;
-        } catch (ex) {
-          throw new _error.default(ex.message || "Could not publish entry.", ex.code || "PUBLISH_ERROR", {
-            entry,
-            storageEntry,
-            originalEntry,
-            originalStorageEntry
-          });
-        }
-      },
-      requestChanges: async (model, id) => {
-        const permission = await checkEntryPermissions({
-          pw: "c"
-        });
-        const originalStorageEntry = await storageOperations.getRevisionById(model, id);
-
-        if (!originalStorageEntry) {
-          throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
-        }
-
-        const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-
-        if (originalEntry.status !== STATUS_REVIEW_REQUESTED) {
-          throw new _error.default("Cannot request changes on an entry that's not under review.", "ENTRY_NOT_UNDER_REVIEW");
-        }
-
-        const identity = context.security.getIdentity();
-
-        if (originalEntry.ownedBy.id === identity.id) {
-          throw new _error.default("You cannot request changes on your own entry.", "CANNOT_REQUEST_CHANGES_ON_OWN_ENTRY");
-        }
-
-        utils.checkOwnership(context, permission, originalEntry);
-
-        const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
-          status: STATUS_CHANGES_REQUESTED
-        });
-
-        let storageEntry = undefined;
-
-        try {
-          await (0, _hooks.beforeRequestChangesHook)({
-            context,
-            model,
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageOperations
-          });
-          storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-          const result = await storageOperations.requestChanges(model, {
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry
-          });
-          await (0, _hooks.afterRequestChangesHook)({
-            context,
-            model,
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry: result,
-            storageOperations
-          });
-          return result;
-        } catch (ex) {
-          throw new _error.default(ex.message || "Could not request changes for the entry.", ex.code || "REQUEST_CHANGES_ERROR", {
-            entry,
-            originalEntry
-          });
-        }
-      },
-      requestReview: async (model, id) => {
-        const permission = await checkEntryPermissions({
-          pw: "r"
-        });
-        const [entryId] = id.split("#");
-        const originalStorageEntry = await storageOperations.getRevisionById(model, id);
-        const latestEntryRevision = await storageOperations.getLatestRevisionByEntryId(model, entryId);
-
-        if (!originalStorageEntry) {
-          throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
-        } else if (!latestEntryRevision) {
-          throw new _handlerGraphql.NotFoundError(`Entry "${id}" does not have latest record`);
-        }
-
-        const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-        const allowedStatuses = [STATUS_DRAFT, STATUS_CHANGES_REQUESTED];
-
-        if (!allowedStatuses.includes(originalEntry.status)) {
-          throw new _error.default("Cannot request review - entry is not a draft nor was a change request issued.", "REQUEST_REVIEW_ERROR", {
-            entry: originalEntry
-          });
-        }
-
-        utils.checkOwnership(context, permission, originalEntry);
-
-        const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
-          status: STATUS_REVIEW_REQUESTED
-        });
-
-        let storageEntry = undefined;
-
-        try {
-          await (0, _hooks.beforeRequestReviewHook)({
-            context,
-            model,
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageOperations
-          });
-          storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-          const result = await storageOperations.requestReview(model, {
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry
-          });
-          await (0, _hooks.afterRequestReviewHook)({
-            context,
-            model,
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry: result,
-            storageOperations
-          });
-          return result;
-        } catch (ex) {
-          throw new _error.default(ex.message || "Could not request review on the entry.", ex.code || "REQUEST_REVIEW_ERROR", {
-            originalEntry,
-            entry
-          });
-        }
-      },
-      unpublish: async (model, id) => {
-        const permission = await checkEntryPermissions({
-          pw: "u"
-        });
-        const [entryId] = id.split("#");
-        const originalStorageEntry = await storageOperations.getPublishedRevisionByEntryId(model, 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
-          });
-        }
-
-        utils.checkOwnership(context, permission, originalStorageEntry);
-        const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-
-        const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
-          status: STATUS_UNPUBLISHED
-        });
-
-        let storageEntry = undefined;
-
-        try {
-          await (0, _hooks.beforeUnpublishHook)({
-            context,
-            model,
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageOperations
-          });
-          storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
-          const result = await storageOperations.unpublish(model, {
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry
-          });
-          await (0, _hooks.afterUnpublishHook)({
-            context,
-            model,
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry: result,
-            storageOperations
-          });
-          return result;
-        } catch (ex) {
-          throw new _error.default(ex.message || "Could not unpublish entry.", ex.code || "UNPUBLISH_ERROR", {
-            originalEntry,
-            originalStorageEntry,
-            entry,
-            storageEntry
-          });
-        }
+        await onAfterRequestChanges.publish({
+          entry,
+          storageEntry: result,
+          model
+        });
+        return result;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not request changes for the entry.", ex.code || "REQUEST_CHANGES_ERROR", {
+          entry,
+          originalEntry
+        });
       }
-    };
-    context.cms = _objectSpread(_objectSpread({}, context.cms || {}), {}, {
-      entries
-    });
-  }
+    },
+    requestEntryReview: async (model, id) => {
+      const permission = await checkEntryPermissions({
+        pw: "r"
+      });
+      const [entryId] = id.split("#");
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id
+      });
+      const latestEntryRevision = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        id: entryId
+      });
 
-});
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
+      } else if (!latestEntryRevision) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" does not have latest record`);
+      }
+
+      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+      const allowedStatuses = [STATUS_DRAFT, STATUS_CHANGES_REQUESTED];
+
+      if (!allowedStatuses.includes(originalEntry.status)) {
+        throw new _error.default("Cannot request review - entry is not a draft nor was a change request issued.", "REQUEST_REVIEW_ERROR", {
+          entry: originalEntry
+        });
+      }
+
+      utils.checkOwnership(context, permission, originalEntry);
+
+      const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
+        status: STATUS_REVIEW_REQUESTED
+      });
+
+      let storageEntry = undefined;
+
+      try {
+        await onBeforeRequestReview.publish({
+          entry,
+          model
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.requestReview(model, {
+          originalEntry,
+          originalStorageEntry,
+          entry,
+          storageEntry
+        });
+        await onAfterRequestReview.publish({
+          entry,
+          storageEntry: result,
+          model
+        });
+        return result;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not request review on the entry.", ex.code || "REQUEST_REVIEW_ERROR", {
+          originalEntry,
+          entry
+        });
+      }
+    },
+    unpublishEntry: async (model, id) => {
+      const permission = await checkEntryPermissions({
+        pw: "u"
+      });
+      const [entryId] = id.split("#");
+      const originalStorageEntry = await storageOperations.entries.getPublishedRevisionByEntryId(model, {
+        tenant: getTenant().id,
+        locale: getLocale().code,
+        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
+        });
+      }
+
+      utils.checkOwnership(context, permission, originalStorageEntry);
+      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+
+      const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
+        status: STATUS_UNPUBLISHED
+      });
+
+      let storageEntry = undefined;
+
+      try {
+        await onBeforeUnpublish.publish({
+          entry,
+          model
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.unpublish(model, {
+          originalEntry,
+          originalStorageEntry,
+          entry,
+          storageEntry
+        });
+        await onAfterUnpublish.publish({
+          entry,
+          storageEntry: result,
+          model
+        });
+        return result;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not unpublish entry.", ex.code || "UNPUBLISH_ERROR", {
+          originalEntry,
+          originalStorageEntry,
+          entry,
+          storageEntry
+        });
+      }
+    }
+  };
+};
 
-exports.default = _default;
-//# sourceMappingURL=contentEntry.crud.js.map
+exports.createContentEntryCrud = createContentEntryCrud;