@webiny/api-headless-cms 0.0.0-mt-3 → 0.0.0-unstable.1e66d121db

package/crud/contentEntry.crud.js

@@ -0,0 +1,1255 @@
+"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 _mdbid = _interopRequireDefault(require("mdbid"));
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _entryDataValidation = require("./contentEntry/entryDataValidation");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _pubsub = require("@webiny/pubsub");
+
+var _beforeCreate = require("./contentEntry/beforeCreate");
+
+var _beforeUpdate = require("./contentEntry/beforeUpdate");
+
+var _utils = require("@webiny/utils");
+
+var _afterDelete = require("./contentEntry/afterDelete");
+
+var _referenceFieldsMapping = require("./contentEntry/referenceFieldsMapping");
+
+var _merge = _interopRequireDefault(require("lodash/merge"));
+
+var _permissions = require("../utils/permissions");
+
+var _access = require("../utils/access");
+
+var _ownership = require("../utils/ownership");
+
+var _entryStorage = require("../utils/entryStorage");
+
+var _valueKeyStorageConverter = require("../utils/converters/valueKeyStorageConverter");
+
+/**
+ * Package mdbid does not have types.
+ */
+// @ts-ignore
+const STATUS_DRAFT = "draft";
+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 || {});
+
+  for (const key in meta) {
+    if (meta[key] !== undefined || meta[key] !== null) {
+      continue;
+    }
+
+    delete meta[key];
+  }
+
+  return meta;
+};
+
+const createEntryId = version => {
+  const entryId = (0, _mdbid.default)();
+  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 getSearchableFields = params => {
+  const {
+    plugins,
+    model,
+    fields
+  } = params;
+  const fieldPluginMap = plugins.byType("cms-model-field-to-graphql").reduce((collection, field) => {
+    collection[field.fieldType] = field;
+    return collection;
+  }, {});
+  return model.fields.filter(field => {
+    if (!field.fieldId) {
+      return false;
+    }
+
+    const plugin = fieldPluginMap[field.type];
+
+    if (!plugin) {
+      return false;
+    } else if (!plugin.fullTextSearch) {
+      return false;
+    } else if (!fields || fields.length === 0) {
+      return true;
+    }
+
+    return fields.includes(field.fieldId);
+  }).map(field => field.fieldId);
+};
+
+const allowedEntryStatus = ["draft", "published", "unpublished"];
+
+const transformEntryStatus = status => {
+  return allowedEntryStatus.includes(status) ? status : "draft";
+};
+
+const createContentEntryCrud = params => {
+  const {
+    storageOperations,
+    context,
+    getIdentity,
+    getTenant
+  } = params;
+  const {
+    plugins
+  } = context; // create
+
+  const onEntryBeforeCreate = (0, _pubsub.createTopic)("cms.onEntryBeforeCreate");
+  const onEntryAfterCreate = (0, _pubsub.createTopic)("cms.onEntryAfterCreate");
+  const onEntryCreateError = (0, _pubsub.createTopic)("cms.onEntryCreateError"); // create 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.onEntryAfterPublic");
+  const onEntryPublishError = (0, _pubsub.createTopic)("cms.onEntryPublishError"); // 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
+
+  const onEntryBeforeGet = (0, _pubsub.createTopic)("cms.onEntryBeforeGet"); // list
+
+  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 deleteEntry = async params => {
+    const {
+      model,
+      entry
+    } = params;
+
+    try {
+      await onEntryBeforeDelete.publish({
+        entry,
+        model
+      });
+      await storageOperations.entries.delete(model, {
+        entry
+      });
+      await onEntryAfterDelete.publish({
+        entry,
+        model
+      });
+    } catch (ex) {
+      await onEntryDeleteError.publish({
+        entry,
+        model,
+        error: ex
+      });
+      throw new _error.default(ex.message || "Could not delete entry.", ex.code || "DELETE_ERROR", {
+        entry
+      });
+    }
+  };
+  /**
+   * A helper to get entries by revision IDs
+   */
+
+
+  const getEntriesByIds = async (initialModel, ids) => {
+    const permission = await checkEntryPermissions({
+      rwd: "r"
+    });
+    await (0, _access.checkModelAccess)(context, initialModel);
+    const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+      model: initialModel,
+      plugins
+    });
+    const entries = await storageOperations.entries.getByIds(model, {
+      ids
+    });
+    return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
+  };
+
+  return {
+    /**
+     * Deprecated - will be removed in 5.35.0
+     */
+    onBeforeEntryCreate: onEntryBeforeCreate,
+    onAfterEntryCreate: onEntryAfterCreate,
+    onBeforeEntryCreateRevision: onEntryBeforeCreateRevision,
+    onAfterEntryCreateRevision: onEntryRevisionAfterCreate,
+    onBeforeEntryUpdate: onEntryBeforeUpdate,
+    onAfterEntryUpdate: onEntryAfterUpdate,
+    onBeforeEntryDelete: onEntryBeforeDelete,
+    onAfterEntryDelete: onEntryAfterDelete,
+    onBeforeEntryDeleteRevision: onEntryRevisionBeforeDelete,
+    onAfterEntryDeleteRevision: onEntryRevisionAfterDelete,
+    onBeforeEntryPublish: onEntryBeforePublish,
+    onAfterEntryPublish: onEntryAfterPublish,
+    onBeforeEntryUnpublish: onEntryBeforeUnpublish,
+    onAfterEntryUnpublish: onEntryAfterUnpublish,
+    onBeforeEntryGet: onEntryBeforeGet,
+    onBeforeEntryList: onEntryBeforeList,
+
+    /**
+     * Released in 5.34.0
+     */
+    onEntryBeforeCreate,
+    onEntryAfterCreate,
+    onEntryCreateError,
+    onEntryRevisionBeforeCreate: onEntryBeforeCreateRevision,
+    onEntryRevisionAfterCreate,
+    onEntryRevisionCreateError: onEntryCreateRevisionError,
+    onEntryBeforeUpdate,
+    onEntryAfterUpdate,
+    onEntryUpdateError,
+    onEntryBeforeDelete,
+    onEntryAfterDelete,
+    onEntryDeleteError,
+    onEntryRevisionBeforeDelete,
+    onEntryRevisionAfterDelete,
+    onEntryRevisionDeleteError,
+    onEntryBeforePublish,
+    onEntryAfterPublish,
+    onEntryPublishError,
+    onEntryBeforeUnpublish,
+    onEntryAfterUnpublish,
+    onEntryUnpublishError,
+    onEntryBeforeGet,
+    onEntryBeforeList,
+
+    /**
+     * Get entries by exact revision IDs from the database.
+     */
+    getEntriesByIds: getEntriesByIds,
+
+    /**
+     * Get a single entry by revision ID from the database.
+     */
+    async getEntryById(initialModel, id) {
+      const where = {
+        id
+      };
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      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;
+    },
+
+    /**
+     * Get published revisions by entry IDs.
+     */
+    async getPublishedEntriesByIds(initialModel, ids) {
+      const permission = await checkEntryPermissions({
+        rwd: "r"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      const entries = await storageOperations.entries.getPublishedByIds(model, {
+        ids
+      });
+      return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
+    },
+
+    /**
+     * Get latest revisions by entry IDs.
+     */
+    async getLatestEntriesByIds(initialModel, ids) {
+      const permission = await checkEntryPermissions({
+        rwd: "r"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      const entries = await storageOperations.entries.getLatestByIds(model, {
+        ids
+      });
+      return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
+    },
+
+    async getEntryRevisions(initialModel, entryId) {
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      return storageOperations.entries.getRevisions(model, {
+        id: entryId
+      });
+    },
+
+    /**
+     * TODO determine if this method is required at all.
+     *
+     * @internal
+     */
+    async getEntry(initialModel, params) {
+      await checkEntryPermissions({
+        rwd: "r"
+      });
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      const {
+        where,
+        sort
+      } = params;
+      await onEntryBeforeGet.publish({
+        where,
+        model
+      });
+      const [items] = await this.listEntries(model, {
+        where,
+        sort,
+        limit: 1
+      });
+
+      if (items.length === 0) {
+        throw new _handlerGraphql.NotFoundError(`Entry not found!`);
+      }
+
+      return items[0];
+    },
+
+    /**
+     * @description Should not be used directly. Internal use only!
+     *
+     * @internal
+     */
+    async listEntries(initialModel, params) {
+      const permission = await checkEntryPermissions({
+        rwd: "r"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      const {
+        where: initialWhere
+      } = params;
+      /**
+       * We always assign tenant and locale because we do not allow one model to have content through multiple tenants.
+       */
+
+      const where = (0, _objectSpread2.default)({}, initialWhere);
+      /**
+       * Possibly only get records which are owned by current user.
+       * Or if searching for the owner set that value - in the case that user can see other entries than their own.
+       */
+
+      const ownedBy = permission.own ? getIdentity().id : where.ownedBy;
+
+      if (ownedBy !== undefined) {
+        where.ownedBy = ownedBy;
+      }
+      /**
+       * Where must contain either latest or published keys.
+       * We cannot list entries without one of those
+       */
+
+
+      if (where.latest && where.published) {
+        throw new _error.default("Cannot list entries that are both published and latest.", "LIST_ENTRIES_ERROR", {
+          where
+        });
+      } else if (!where.latest && !where.published) {
+        throw new _error.default("Cannot list entries if we do not have latest or published defined.", "LIST_ENTRIES_ERROR", {
+          where
+        });
+      }
+
+      const fields = getSearchableFields({
+        model,
+        plugins: context.plugins,
+        fields: 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), {}, {
+          where,
+          fields
+        }));
+        const meta = {
+          hasMoreItems,
+          totalCount,
+
+          /**
+           * Cursor should be null if there are no more items to load.
+           * Just make sure of that, disregarding what is returned from the storageOperations.entries.list method.
+           */
+          cursor: hasMoreItems ? cursor : null
+        };
+        return [items, meta];
+      } catch (ex) {
+        throw new _error.default("Error while fetching entries from storage.", "LIST_ENTRIES_ERROR", {
+          params,
+          error: {
+            message: ex.message,
+            code: ex.code,
+            data: ex.data
+          },
+          model,
+          fields
+        });
+      }
+    },
+
+    async listLatestEntries(model, params) {
+      const where = (params === null || params === void 0 ? void 0 : params.where) || {};
+      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(initialModel, inputData) {
+      await checkEntryPermissions({
+        rwd: "w"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      /**
+       * Make sure we only work with fields that are defined in the model.
+       */
+
+      const initialInput = mapAndCleanCreateInputData(model, inputData);
+      await (0, _entryDataValidation.validateModelEntryData)({
+        context,
+        model,
+        data: initialInput
+      });
+      const input = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+        context,
+        model,
+        input: initialInput,
+        validateEntries: true
+      });
+      const identity = context.security.getIdentity();
+      const locale = this.getLocale();
+      const owner = {
+        id: identity.id,
+        displayName: identity.displayName,
+        type: identity.type
+      };
+      const {
+        id,
+        entryId,
+        version
+      } = createEntryId(1);
+      const entry = {
+        webinyVersion: context.WEBINY_VERSION,
+        tenant: getTenant().id,
+        entryId,
+        id,
+        modelId: model.modelId,
+        locale: locale.code,
+        createdOn: new Date().toISOString(),
+        savedOn: new Date().toISOString(),
+        createdBy: owner,
+        ownedBy: owner,
+        version,
+        locked: false,
+        status: STATUS_DRAFT,
+        values: input
+      };
+      let storageEntry = null;
+
+      try {
+        await onEntryBeforeCreate.publish({
+          entry,
+          input,
+          model
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.create(model, {
+          entry,
+          storageEntry
+        });
+        await onEntryAfterCreate.publish({
+          entry,
+          storageEntry: result,
+          model,
+          input
+        });
+        return result;
+      } catch (ex) {
+        await onEntryCreateError.publish({
+          error: ex,
+          entry,
+          model,
+          input
+        });
+        throw new _error.default(ex.message || "Could not create content entry.", ex.code || "CREATE_ENTRY_ERROR", ex.data || {
+          error: ex,
+          input,
+          entry,
+          storageEntry
+        });
+      }
+    },
+
+    async createEntryRevisionFrom(initialModel, sourceId, inputData) {
+      const permission = await checkEntryPermissions({
+        rwd: "w"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      /**
+       * Make sure we only work with fields that are defined in the model.
+       */
+
+      const input = mapAndCleanUpdatedInputData(model, inputData);
+      /**
+       * Entries are identified by a common parent ID + Revision number.
+       */
+
+      const {
+        id: uniqueId
+      } = (0, _utils.parseIdentifier)(sourceId);
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        id: sourceId
+      });
+      const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+        id: uniqueId
+      });
+
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${sourceId}" of model "${model.modelId}" was not found.`);
+      }
+      /**
+       * We need to convert data from DB to its original form before using it further.
+       */
+
+
+      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+      const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
+      await (0, _entryDataValidation.validateModelEntryData)({
+        context,
+        model,
+        data: initialValues,
+        entry: originalEntry
+      });
+      const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+        context,
+        model,
+        input: initialValues,
+        validateEntries: false
+      });
+      (0, _ownership.checkOwnership)(context, permission, originalEntry);
+      const identity = context.security.getIdentity();
+      const latestId = latestStorageEntry ? latestStorageEntry.id : sourceId;
+      const {
+        id,
+        version: nextVersion
+      } = increaseEntryIdVersion(latestId);
+      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+        id,
+        version: nextVersion,
+        savedOn: new Date().toISOString(),
+        createdOn: new Date().toISOString(),
+        createdBy: {
+          id: identity.id,
+          displayName: identity.displayName,
+          type: identity.type
+        },
+        locked: false,
+        publishedOn: undefined,
+        status: STATUS_DRAFT,
+        values
+      });
+      let storageEntry = null;
+
+      try {
+        await onEntryBeforeCreateRevision.publish({
+          input,
+          entry,
+          original: originalEntry,
+          model
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.createRevisionFrom(model, {
+          entry,
+          storageEntry
+        });
+        await onEntryRevisionAfterCreate.publish({
+          input,
+          entry,
+          model,
+          original: originalEntry,
+          storageEntry: result
+        });
+        return result;
+      } catch (ex) {
+        await onEntryCreateRevisionError.publish({
+          entry,
+          model,
+          input,
+          error: ex
+        });
+        throw new _error.default(ex.message || "Could not create entry from existing one.", ex.code || "CREATE_FROM_REVISION_ERROR", {
+          error: ex,
+          entry,
+          storageEntry,
+          originalEntry,
+          originalStorageEntry
+        });
+      }
+    },
+
+    async updateEntry(initialModel, id, inputData, metaInput) {
+      const permission = await checkEntryPermissions({
+        rwd: "w"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      /**
+       * Make sure we only work with fields that are defined in the model.
+       */
+
+      const input = mapAndCleanUpdatedInputData(model, inputData);
+      /**
+       * The entry we are going to update.
+       */
+
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        id
+      });
+
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" of model "${model.modelId}" was not found.`);
+      }
+
+      if (originalStorageEntry.locked) {
+        throw new _error.default(`Cannot update entry because it's locked.`, "CONTENT_ENTRY_UPDATE_ERROR");
+      }
+
+      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+      await (0, _entryDataValidation.validateModelEntryData)({
+        context,
+        model,
+        data: input,
+        entry: originalEntry
+      });
+      (0, _ownership.checkOwnership)(context, permission, originalEntry);
+      const initialValues = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry.values), input);
+      const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+        context,
+        model,
+        input: initialValues,
+        validateEntries: false
+      });
+      /**
+       * If users wants to remove a key from meta values, they need to send meta key with the null value.
+       */
+
+      const meta = createEntryMeta(metaInput, originalEntry.meta);
+      /**
+       * We always send the full entry to the hooks and storage operations update.
+       */
+
+      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+        savedOn: new Date().toISOString(),
+        values,
+        meta,
+        status: transformEntryStatus(originalEntry.status)
+      });
+      let storageEntry = null;
+
+      try {
+        await onEntryBeforeUpdate.publish({
+          entry,
+          model,
+          input,
+          original: originalEntry
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.update(model, {
+          entry,
+          storageEntry
+        });
+        await onEntryAfterUpdate.publish({
+          entry,
+          storageEntry: result,
+          model,
+          input,
+          original: originalEntry
+        });
+        return result;
+      } catch (ex) {
+        await onEntryUpdateError.publish({
+          entry,
+          model,
+          input,
+          error: ex
+        });
+        throw new _error.default(ex.message || "Could not update existing entry.", ex.code || "UPDATE_ERROR", {
+          error: ex,
+          entry,
+          storageEntry,
+          originalEntry,
+          input
+        });
+      }
+    },
+
+    async republishEntry(initialModel, id) {
+      await checkEntryPermissions({
+        rwd: "w"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      /**
+       * Fetch the entry from the storage.
+       */
+
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        id
+      });
+
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" was not found!`);
+      }
+
+      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+      /**
+       * We can only process published entries.
+       */
+
+      if (originalEntry.status !== "published") {
+        throw new _error.default("Entry with given ID is not published!", "NOT_PUBLISHED_ERROR", {
+          id,
+          original: originalEntry
+        });
+      }
+
+      const values = await (0, _referenceFieldsMapping.referenceFieldsMapping)({
+        context,
+        model,
+        input: originalEntry.values,
+        validateEntries: false
+      });
+      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+        savedOn: new Date().toISOString(),
+        webinyVersion: context.WEBINY_VERSION,
+        values
+      });
+      const storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+      /**
+       * First we need to update existing entry.
+       */
+
+      try {
+        await storageOperations.entries.update(model, {
+          entry,
+          storageEntry
+        });
+      } catch (ex) {
+        throw new _error.default("Could not update existing entry with new data while re-publishing.", "REPUBLISH_UPDATE_ERROR", {
+          entry
+        });
+      }
+      /**
+       * Then we move onto publishing it again.
+       */
+
+
+      try {
+        return await storageOperations.entries.publish(model, {
+          entry,
+          storageEntry
+        });
+      } catch (ex) {
+        throw new _error.default("Could not publish existing entry while re-publishing.", "REPUBLISH_PUBLISH_ERROR", {
+          entry
+        });
+      }
+    },
+
+    async deleteEntryRevision(initialModel, revisionId) {
+      const permission = await checkEntryPermissions({
+        rwd: "d"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      const {
+        id: entryId,
+        version
+      } = (0, _utils.parseIdentifier)(revisionId);
+      const storageEntryToDelete = await storageOperations.entries.getRevisionById(model, {
+        id: revisionId
+      });
+      const latestStorageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+        id: entryId
+      });
+      const previousStorageEntry = await storageOperations.entries.getPreviousRevision(model, {
+        entryId,
+        version: version
+      });
+
+      if (!storageEntryToDelete) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${revisionId}" was not found!`);
+      }
+
+      (0, _ownership.checkOwnership)(context, permission, storageEntryToDelete);
+      const latestEntryRevisionId = latestStorageEntry ? latestStorageEntry.id : null;
+      const entryToDelete = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntryToDelete);
+      /**
+       * If targeted record is the latest entry record and there is no previous one, we need to run full delete with hooks.
+       * At this point deleteRevision hooks are not fired.
+       */
+
+      if (entryToDelete.id === latestEntryRevisionId && !previousStorageEntry) {
+        return await deleteEntry({
+          model,
+          entry: entryToDelete
+        });
+      }
+      /**
+       * If targeted record is latest entry revision, set the previous one as the new latest
+       */
+
+
+      let entryToSetAsLatest = null;
+      let storageEntryToSetAsLatest = null;
+
+      if (entryToDelete.id === latestEntryRevisionId && previousStorageEntry) {
+        entryToSetAsLatest = await (0, _entryStorage.entryFromStorageTransform)(context, model, previousStorageEntry);
+        storageEntryToSetAsLatest = previousStorageEntry;
+      }
+
+      try {
+        await onEntryRevisionBeforeDelete.publish({
+          entry: entryToDelete,
+          model
+        });
+        await storageOperations.entries.deleteRevision(model, {
+          entry: entryToDelete,
+          storageEntry: storageEntryToDelete,
+          latestEntry: entryToSetAsLatest,
+          latestStorageEntry: storageEntryToSetAsLatest
+        });
+        await onEntryRevisionAfterDelete.publish({
+          entry: entryToDelete,
+          model
+        });
+      } catch (ex) {
+        await onEntryRevisionDeleteError.publish({
+          entry: entryToDelete,
+          model,
+          error: ex
+        });
+        throw new _error.default(ex.message, ex.code || "DELETE_REVISION_ERROR", {
+          error: ex,
+          entry: entryToDelete,
+          storageEntry: storageEntryToDelete,
+          latestEntry: entryToSetAsLatest,
+          latestStorageEntry: storageEntryToSetAsLatest
+        });
+      }
+    },
+
+    async deleteEntry(initialModel, entryId) {
+      const permission = await checkEntryPermissions({
+        rwd: "d"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      const storageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
+        id: entryId
+      });
+
+      if (!storageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${entryId}" was not found!`);
+      }
+
+      (0, _ownership.checkOwnership)(context, permission, storageEntry);
+      const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntry);
+      return await deleteEntry({
+        model,
+        entry
+      });
+    },
+
+    async publishEntry(initialModel, id) {
+      const permission = await checkEntryPermissions({
+        pw: "p"
+      });
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
+        id
+      });
+
+      if (!originalStorageEntry) {
+        throw new _handlerGraphql.NotFoundError(`Entry "${id}" in the model "${model.modelId}" was not found.`);
+      }
+
+      (0, _ownership.checkOwnership)(context, permission, originalStorageEntry);
+      const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
+      const currentDate = new Date().toISOString();
+      const entry = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originalEntry), {}, {
+        status: STATUS_PUBLISHED,
+        locked: true,
+        savedOn: currentDate,
+        publishedOn: currentDate
+      });
+      let storageEntry = null;
+
+      try {
+        await onEntryBeforePublish.publish({
+          entry,
+          model
+        });
+        storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
+        const result = await storageOperations.entries.publish(model, {
+          entry,
+          storageEntry
+        });
+        await onEntryAfterPublish.publish({
+          entry,
+          storageEntry: result,
+          model
+        });
+        return result;
+      } catch (ex) {
+        await onEntryPublishError.publish({
+          entry,
+          model,
+          error: ex
+        });
+        throw new _error.default(ex.message || "Could not publish entry.", ex.code || "PUBLISH_ERROR", {
+          error: ex,
+          entry,
+          storageEntry,
+          originalEntry,
+          originalStorageEntry
+        });
+      }
+    },
+
+    async unpublishEntry(initialModel, id) {
+      const permission = await checkEntryPermissions({
+        pw: "u"
+      });
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      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
+        });
+      }
+    }
+
+  };
+};
+
+exports.createContentEntryCrud = createContentEntryCrud;