@webiny/api-headless-cms 0.0.0-mt-2 → 0.0.0-unstable.5e7233243f

package/{content/plugins/crud → crud}/contentEntry.crud.js

@@ -13,8 +13,6 @@ var _mdbid = _interopRequireDefault(require("mdbid"));
 
 var _handlerGraphql = require("@webiny/handler-graphql");
 
-var utils = _interopRequireWildcard(require("../../../utils"));
-
 var _entryDataValidation = require("./contentEntry/entryDataValidation");
 
 var _error = _interopRequireDefault(require("@webiny/error"));
@@ -25,19 +23,27 @@ var _beforeCreate = require("./contentEntry/beforeCreate");
 
 var _beforeUpdate = require("./contentEntry/beforeUpdate");
 
-var _utils2 = require("@webiny/utils");
-
-var _entryStorage = require("../utils/entryStorage");
+var _utils = require("@webiny/utils");
 
 var _afterDelete = require("./contentEntry/afterDelete");
 
-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); }
+var _referenceFieldsMapping = require("./contentEntry/referenceFieldsMapping");
+
+var _merge = _interopRequireDefault(require("lodash/merge"));
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _permissions = require("../utils/permissions");
+
+var _access = require("../utils/access");
+
+var _ownership = require("../utils/ownership");
+
+var _entryStorage = require("../utils/entryStorage");
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+var _valueKeyStorageConverter = require("../utils/converters/valueKeyStorageConverter");
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 const STATUS_DRAFT = "draft";
 exports.STATUS_DRAFT = STATUS_DRAFT;
@@ -50,30 +56,143 @@ exports.STATUS_CHANGES_REQUESTED = STATUS_CHANGES_REQUESTED;
 const STATUS_REVIEW_REQUESTED = "reviewRequested";
 exports.STATUS_REVIEW_REQUESTED = STATUS_REVIEW_REQUESTED;
 
-const cleanInputData = (model, inputData) => {
+/**
+ * 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) => {
-    acc[field.fieldId] = inputData[field.fieldId];
+    /**
+     * 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 cleanUpdatedInputData = (model, input) => {
+
+const mapAndCleanUpdatedInputData = (model, input) => {
   return model.fields.reduce((acc, field) => {
-    if (input[field.fieldId] === undefined) {
+    /**
+     * 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] = input[field.fieldId];
+    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, _utils2.createIdentifier)({
+    id: (0, _utils.createIdentifier)({
       id: entryId,
       version
     })
@@ -81,71 +200,105 @@ const createEntryId = version => {
 };
 
 const increaseEntryIdVersion = id => {
-  if (id.includes("#") === false) {
+  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
     });
   }
 
-  const [entryId, version] = id.split("#");
-  const ver = parseInt(version) + 1;
   return {
     entryId,
-    version: ver,
-    id: (0, _utils2.createIdentifier)({
+    version: version + 1,
+    id: (0, _utils.createIdentifier)({
       id: entryId,
-      version: ver
+      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 createContentEntryCrud = params => {
   const {
     storageOperations,
     context,
-    getTenant,
-    getLocale,
-    getIdentity
+    getIdentity,
+    getTenant
   } = 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)();
+  const {
+    plugins
+  } = context;
+  const onBeforeEntryCreate = (0, _pubsub.createTopic)();
+  const onAfterEntryCreate = (0, _pubsub.createTopic)();
+  const onBeforeEntryCreateRevision = (0, _pubsub.createTopic)();
+  const onAfterEntryCreateRevision = (0, _pubsub.createTopic)();
+  const onBeforeEntryUpdate = (0, _pubsub.createTopic)();
+  const onAfterEntryUpdate = (0, _pubsub.createTopic)();
+  const onBeforeEntryPublish = (0, _pubsub.createTopic)();
+  const onAfterEntryPublish = (0, _pubsub.createTopic)();
+  const onBeforeEntryUnpublish = (0, _pubsub.createTopic)();
+  const onAfterEntryUnpublish = (0, _pubsub.createTopic)();
+  const onBeforeEntryRequestChanges = (0, _pubsub.createTopic)();
+  const onAfterEntryRequestChanges = (0, _pubsub.createTopic)();
+  const onBeforeEntryRequestReview = (0, _pubsub.createTopic)();
+  const onAfterEntryRequestReview = (0, _pubsub.createTopic)();
+  const onBeforeEntryDelete = (0, _pubsub.createTopic)();
+  const onAfterEntryDelete = (0, _pubsub.createTopic)();
+  const onBeforeEntryDeleteRevision = (0, _pubsub.createTopic)();
+  const onAfterEntryDeleteRevision = (0, _pubsub.createTopic)();
+  const onBeforeEntryGet = (0, _pubsub.createTopic)();
+  const onBeforeEntryList = (0, _pubsub.createTopic)();
   /**
    * We need to assign some default behaviors.
    */
 
   (0, _beforeCreate.assignBeforeEntryCreate)({
     context,
-    onBeforeCreate
+    onBeforeEntryCreate
   });
   (0, _beforeUpdate.assignBeforeEntryUpdate)({
     context,
-    onBeforeUpdate
+    onBeforeEntryUpdate
   });
   (0, _afterDelete.assignAfterEntryDelete)({
     context,
-    onAfterDelete
+    onAfterEntryDelete
   });
 
   const checkEntryPermissions = check => {
-    return utils.checkPermissions(context, "cms.contentEntry", check);
+    return (0, _permissions.checkPermissions)(context, "cms.contentEntry", check);
   };
   /**
    * A helper to delete the entire entry.
@@ -155,20 +308,18 @@ const createContentEntryCrud = params => {
   const deleteEntry = async params => {
     const {
       model,
-      entry,
-      storageEntry
+      entry
     } = params;
 
     try {
-      await onBeforeDelete.publish({
+      await onBeforeEntryDelete.publish({
         entry,
         model
       });
       await storageOperations.entries.delete(model, {
-        entry,
-        storageEntry
+        entry
       });
-      await onAfterDelete.publish({
+      await onAfterEntryDelete.publish({
         entry,
         model
       });
@@ -183,38 +334,42 @@ const createContentEntryCrud = params => {
    */
 
 
-  const getEntriesByIds = async (model, ids) => {
+  const getEntriesByIds = async (initialModel, ids) => {
     const permission = await checkEntryPermissions({
       rwd: "r"
     });
-    await utils.checkModelAccess(context, model);
+    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 => utils.validateOwnership(context, permission, entry));
+    return entries.filter(entry => (0, _ownership.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,
+    onBeforeEntryCreate,
+    onAfterEntryCreate,
+    onBeforeEntryCreateRevision,
+    onAfterEntryCreateRevision,
+    onBeforeEntryUpdate,
+    onAfterEntryUpdate,
+    onBeforeEntryDelete,
+    onAfterEntryDelete,
+    onBeforeEntryDeleteRevision,
+    onAfterEntryDeleteRevision,
+    onBeforeEntryPublish,
+    onAfterEntryPublish,
+    onBeforeEntryUnpublish,
+    onAfterEntryUnpublish,
+    onBeforeEntryRequestChanges,
+    onAfterEntryRequestChanges,
+    onBeforeEntryRequestReview,
+    onAfterEntryRequestReview,
+    onBeforeEntryGet,
+    onBeforeEntryList,
 
     /**
      * Get entries by exact revision IDs from the database.
@@ -224,15 +379,19 @@ const createContentEntryCrud = params => {
     /**
      * Get a single entry by revision ID from the database.
      */
-    getEntryById: async (model, id) => {
+    getEntryById: async (initialModel, id) => {
       const where = {
         id
       };
-      await onBeforeGet.publish({
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      await onBeforeEntryGet.publish({
         where,
         model
       });
-      const [entry] = await getEntriesByIds(model, [where.id]);
+      const [entry] = await getEntriesByIds(model, [id]);
 
       if (!entry) {
         throw new _handlerGraphql.NotFoundError(`Entry by ID "${id}" not found.`);
@@ -244,44 +403,66 @@ const createContentEntryCrud = params => {
     /**
      * Get published revisions by entry IDs.
      */
-    getPublishedEntriesByIds: async (model, ids) => {
+    getPublishedEntriesByIds: async (initialModel, ids) => {
       const permission = await checkEntryPermissions({
         rwd: "r"
       });
-      await utils.checkModelAccess(context, model);
+      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 => utils.validateOwnership(context, permission, entry));
+      return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
     },
 
     /**
      * Get latest revisions by entry IDs.
      */
-    getLatestEntriesByIds: async (model, ids) => {
+    getLatestEntriesByIds: async (initialModel, ids) => {
       const permission = await checkEntryPermissions({
         rwd: "r"
       });
-      await utils.checkModelAccess(context, model);
+      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 => utils.validateOwnership(context, permission, entry));
+      return entries.filter(entry => (0, _ownership.validateOwnership)(context, permission, entry));
     },
-    getEntryRevisions: async (model, entryId) => {
+    getEntryRevisions: async (initialModel, entryId) => {
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
       return storageOperations.entries.getRevisions(model, {
         id: entryId
       });
     },
-    getEntry: async (model, params) => {
+
+    /**
+     * TODO determine if this method is required at all.
+     *
+     * @internal
+     */
+    getEntry: async (initialModel, params) => {
       await checkEntryPermissions({
         rwd: "r"
       });
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
       const {
         where,
         sort
       } = params;
-      await onBeforeGet.publish({
+      await onBeforeEntryGet.publish({
         where,
         model
       });
@@ -297,54 +478,98 @@ const createContentEntryCrud = params => {
 
       return items[0];
     },
-    listEntries: async (model, params) => {
+
+    /**
+     * @description Should not be used directly. Internal use only!
+     *
+     * @internal
+     */
+    listEntries: async (initialModel, params) => {
       const permission = await checkEntryPermissions({
         rwd: "r"
       });
-      await utils.checkModelAccess(context, model);
-      const where = params.where || {};
+      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 = _objectSpread({}, 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;
 
-      const listWhere = _objectSpread(_objectSpread({}, where), {}, {
-        tenant: where.tenant || getTenant().id,
-        locale: where.locale || getLocale().code
-      });
+      const ownedBy = permission.own ? getIdentity().id : where.ownedBy;
 
       if (ownedBy !== undefined) {
-        listWhere.ownedBy = ownedBy;
+        where.ownedBy = ownedBy;
       }
+      /**
+       * Where must contain either latest or published keys.
+       * We cannot list entries without one of those
+       */
 
-      await onBeforeList.publish({
-        where: listWhere,
-        model
+
+      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 || []
       });
-      const {
-        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];
+
+      try {
+        await onBeforeEntryList.publish({
+          where,
+          model
+        });
+        const {
+          hasMoreItems,
+          totalCount,
+          cursor,
+          items
+        } = await storageOperations.entries.list(model, _objectSpread(_objectSpread({}, 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: ex,
+          model,
+          fields
+        });
+      }
     },
     listLatestEntries: async function (model, params) {
-      const where = params ? params.where : {};
+      const where = (params === null || params === void 0 ? void 0 : params.where) || {};
       return context.cms.listEntries(model, _objectSpread(_objectSpread({
         sort: ["createdOn_DESC"]
       }, params || {}), {}, {
@@ -354,7 +579,7 @@ const createContentEntryCrud = params => {
       }));
     },
     listPublishedEntries: async function (model, params) {
-      const where = params ? params.where : {};
+      const where = (params === null || params === void 0 ? void 0 : params.where) || {};
       return context.cms.listEntries(model, _objectSpread(_objectSpread({
         sort: ["createdOn_DESC"]
       }, params || {}), {}, {
@@ -363,17 +588,31 @@ const createContentEntryCrud = params => {
         })
       }));
     },
-    createEntry: async (model, inputData) => {
+    createEntry: async (initialModel, inputData) => {
       await checkEntryPermissions({
         rwd: "w"
       });
-      await utils.checkModelAccess(context, model);
+      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 = cleanInputData(model, inputData);
-      await (0, _entryDataValidation.validateModelEntryData)(context, model, input);
+      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 = context.cms.getLocale();
       const owner = {
@@ -388,7 +627,7 @@ const createContentEntryCrud = params => {
       } = createEntryId(1);
       const entry = {
         webinyVersion: context.WEBINY_VERSION,
-        tenant: context.tenancy.getCurrentTenant().id,
+        tenant: getTenant().id,
         entryId,
         id,
         modelId: model.modelId,
@@ -405,18 +644,17 @@ const createContentEntryCrud = params => {
       let storageEntry = null;
 
       try {
-        await onBeforeCreate.publish({
+        await onBeforeEntryCreate.publish({
           entry,
           input,
           model
         });
         storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
         const result = await storageOperations.entries.create(model, {
-          input,
           entry,
           storageEntry
         });
-        await onAfterCreate.publish({
+        await onAfterEntryCreate.publish({
           entry,
           storageEntry: result,
           model,
@@ -432,21 +670,27 @@ const createContentEntryCrud = params => {
         });
       }
     },
-    createEntryRevisionFrom: async (model, sourceId, inputData = {}) => {
+    createEntryRevisionFrom: async (initialModel, sourceId, inputData) => {
       const permission = await checkEntryPermissions({
         rwd: "w"
       });
-      await utils.checkModelAccess(context, model);
+      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 = cleanUpdatedInputData(model, inputData);
+      const input = mapAndCleanUpdatedInputData(model, inputData);
       /**
        * Entries are identified by a common parent ID + Revision number.
        */
 
-      const [uniqueId] = sourceId.split("#");
+      const {
+        id: uniqueId
+      } = (0, _utils.parseIdentifier)(sourceId);
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
         id: sourceId
       });
@@ -464,11 +708,21 @@ const createContentEntryCrud = params => {
 
       const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
 
-      const values = _objectSpread(_objectSpread({}, originalEntry.values), input);
+      const initialValues = _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);
+      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 {
@@ -487,30 +741,30 @@ const createContentEntryCrud = params => {
           type: identity.type
         },
         locked: false,
-        publishedOn: null,
+        publishedOn: undefined,
         status: STATUS_DRAFT,
         values
       });
 
-      let storageEntry = undefined;
+      let storageEntry = null;
 
       try {
-        await onBeforeCreateRevision.publish({
+        await onBeforeEntryCreateRevision.publish({
+          input,
           entry,
+          original: originalEntry,
           model
         });
         storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
         const result = await storageOperations.entries.createRevisionFrom(model, {
           entry,
-          storageEntry,
-          originalEntry,
-          originalStorageEntry,
-          latestEntry,
-          latestStorageEntry
+          storageEntry
         });
-        await onAfterCreateRevision.publish({
+        await onAfterEntryCreateRevision.publish({
+          input,
           entry,
           model,
+          original: originalEntry,
           storageEntry: result
         });
         return result;
@@ -524,21 +778,20 @@ const createContentEntryCrud = params => {
         });
       }
     },
-    updateEntry: async (model, id, inputData) => {
+    updateEntry: async (initialModel, id, inputData, metaInput) => {
       const permission = await checkEntryPermissions({
         rwd: "w"
       });
-      await utils.checkModelAccess(context, model);
+      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 = cleanInputData(model, inputData);
-      /**
-       * Validate data early. We don't want to query DB if input data is invalid.
-       */
-
-      await (0, _entryDataValidation.validateModelEntryData)(context, model, input);
+      const input = mapAndCleanUpdatedInputData(model, inputData);
       /**
        * The entry we are going to update.
        */
@@ -556,20 +809,41 @@ const createContentEntryCrud = params => {
       }
 
       const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
-      utils.checkOwnership(context, permission, originalEntry);
+      await (0, _entryDataValidation.validateModelEntryData)({
+        context,
+        model,
+        data: input,
+        entry: originalEntry
+      });
+      (0, _ownership.checkOwnership)(context, permission, originalEntry);
+
+      const initialValues = _objectSpread(_objectSpread({}, 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 = _objectSpread(_objectSpread({}, originalEntry), {}, {
         savedOn: new Date().toISOString(),
-        values: _objectSpread(_objectSpread({}, originalEntry.values), input)
+        values,
+        meta
       });
 
-      let storageEntry = undefined;
+      let storageEntry = null;
 
       try {
-        await onBeforeUpdate.publish({
+        await onBeforeEntryUpdate.publish({
           entry,
           model,
           input,
@@ -577,13 +851,10 @@ const createContentEntryCrud = params => {
         });
         storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
         const result = await storageOperations.entries.update(model, {
-          originalEntry,
-          originalStorageEntry,
           entry,
-          storageEntry,
-          input
+          storageEntry
         });
-        await onAfterUpdate.publish({
+        await onAfterEntryUpdate.publish({
           entry,
           storageEntry: result,
           model,
@@ -601,15 +872,96 @@ const createContentEntryCrud = params => {
         });
       }
     },
-    deleteEntryRevision: async (model, revisionId) => {
+    republishEntry: async (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 = _objectSpread(_objectSpread({}, 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
+        });
+      }
+    },
+    deleteEntryRevision: async (initialModel, revisionId) => {
       const permission = await checkEntryPermissions({
         rwd: "d"
       });
-      await utils.checkModelAccess(context, model);
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
       const {
         id: entryId,
         version
-      } = (0, _utils2.parseIdentifier)(revisionId);
+      } = (0, _utils.parseIdentifier)(revisionId);
       const storageEntryToDelete = await storageOperations.entries.getRevisionById(model, {
         id: revisionId
       });
@@ -618,14 +970,14 @@ const createContentEntryCrud = params => {
       });
       const previousStorageEntry = await storageOperations.entries.getPreviousRevision(model, {
         entryId,
-        version
+        version: version
       });
 
       if (!storageEntryToDelete) {
         throw new _handlerGraphql.NotFoundError(`Entry "${revisionId}" was not found!`);
       }
 
-      utils.checkOwnership(context, permission, storageEntryToDelete);
+      (0, _ownership.checkOwnership)(context, permission, storageEntryToDelete);
       const latestEntryRevisionId = latestStorageEntry ? latestStorageEntry.id : null;
       const entryToDelete = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntryToDelete);
       /**
@@ -636,8 +988,7 @@ const createContentEntryCrud = params => {
       if (entryToDelete.id === latestEntryRevisionId && !previousStorageEntry) {
         return await deleteEntry({
           model,
-          entry: entryToDelete,
-          storageEntry: storageEntryToDelete
+          entry: entryToDelete
         });
       }
       /**
@@ -648,41 +999,45 @@ const createContentEntryCrud = params => {
       let entryToSetAsLatest = null;
       let storageEntryToSetAsLatest = null;
 
-      if (entryToDelete.id === latestEntryRevisionId) {
+      if (entryToDelete.id === latestEntryRevisionId && previousStorageEntry) {
         entryToSetAsLatest = await (0, _entryStorage.entryFromStorageTransform)(context, model, previousStorageEntry);
         storageEntryToSetAsLatest = previousStorageEntry;
       }
 
       try {
-        await onBeforeDeleteRevision.publish({
+        await onBeforeEntryDeleteRevision.publish({
           entry: entryToDelete,
           model
         });
         await storageOperations.entries.deleteRevision(model, {
-          entryToDelete,
-          storageEntryToDelete,
-          entryToSetAsLatest,
-          storageEntryToSetAsLatest
+          entry: entryToDelete,
+          storageEntry: storageEntryToDelete,
+          latestEntry: entryToSetAsLatest,
+          latestStorageEntry: storageEntryToSetAsLatest
         });
-        await onAfterDeleteRevision.publish({
+        await onAfterEntryDeleteRevision.publish({
           entry: entryToDelete,
           model
         });
       } catch (ex) {
         throw new _error.default(ex.message, ex.code || "DELETE_REVISION_ERROR", {
           error: ex,
-          entryToDelete,
-          storageEntryToDelete,
-          entryToSetAsLatest,
-          storageEntryToSetAsLatest
+          entry: entryToDelete,
+          storageEntry: storageEntryToDelete,
+          latestEntry: entryToSetAsLatest,
+          latestStorageEntry: storageEntryToSetAsLatest
         });
       }
     },
-    deleteEntry: async (model, entryId) => {
+    deleteEntry: async (initialModel, entryId) => {
       const permission = await checkEntryPermissions({
         rwd: "d"
       });
-      await utils.checkModelAccess(context, model);
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
       const storageEntry = await storageOperations.entries.getLatestRevisionByEntryId(model, {
         id: entryId
       });
@@ -691,19 +1046,22 @@ const createContentEntryCrud = params => {
         throw new _handlerGraphql.NotFoundError(`Entry "${entryId}" was not found!`);
       }
 
-      utils.checkOwnership(context, permission, storageEntry);
+      (0, _ownership.checkOwnership)(context, permission, storageEntry);
       const entry = await (0, _entryStorage.entryFromStorageTransform)(context, model, storageEntry);
       return await deleteEntry({
         model,
-        entry,
-        storageEntry
+        entry
       });
     },
-    publishEntry: async (model, id) => {
+    publishEntry: async (initialModel, id) => {
       const permission = await checkEntryPermissions({
         pw: "p"
       });
-      await utils.checkModelAccess(context, model);
+      await (0, _access.checkModelAccess)(context, initialModel);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
         id
       });
@@ -712,7 +1070,7 @@ const createContentEntryCrud = params => {
         throw new _handlerGraphql.NotFoundError(`Entry "${id}" in the model "${model.modelId}" was not found.`);
       }
 
-      utils.checkOwnership(context, permission, originalStorageEntry);
+      (0, _ownership.checkOwnership)(context, permission, originalStorageEntry);
       const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
       const currentDate = new Date().toISOString();
 
@@ -723,21 +1081,19 @@ const createContentEntryCrud = params => {
         publishedOn: currentDate
       });
 
-      let storageEntry = undefined;
+      let storageEntry = null;
 
       try {
-        await onBeforePublish.publish({
+        await onBeforeEntryPublish.publish({
           entry,
           model
         });
         storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
         const result = await storageOperations.entries.publish(model, {
           entry,
-          storageEntry,
-          originalEntry,
-          originalStorageEntry
+          storageEntry
         });
-        await onAfterPublish.publish({
+        await onAfterEntryPublish.publish({
           entry,
           storageEntry: result,
           model
@@ -753,10 +1109,14 @@ const createContentEntryCrud = params => {
         });
       }
     },
-    requestEntryChanges: async (model, id) => {
+    requestEntryChanges: async (initialModel, id) => {
       const permission = await checkEntryPermissions({
         pw: "c"
       });
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
         id
       });
@@ -777,27 +1137,25 @@ const createContentEntryCrud = params => {
         throw new _error.default("You cannot request changes on your own entry.", "CANNOT_REQUEST_CHANGES_ON_OWN_ENTRY");
       }
 
-      utils.checkOwnership(context, permission, originalEntry);
+      (0, _ownership.checkOwnership)(context, permission, originalEntry);
 
       const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
         status: STATUS_CHANGES_REQUESTED
       });
 
-      let storageEntry = undefined;
+      let storageEntry = null;
 
       try {
-        await onBeforeRequestChanges.publish({
+        await onBeforeEntryRequestChanges.publish({
           entry,
           model
         });
         storageEntry = await (0, _entryStorage.entryToStorageTransform)(context, model, entry);
         const result = await storageOperations.entries.requestChanges(model, {
-          originalEntry,
-          originalStorageEntry,
           entry,
           storageEntry
         });
-        await onAfterRequestChanges.publish({
+        await onAfterEntryRequestChanges.publish({
           entry,
           storageEntry: result,
           model
@@ -810,11 +1168,17 @@ const createContentEntryCrud = params => {
         });
       }
     },
-    requestEntryReview: async (model, id) => {
+    requestEntryReview: async (initialModel, id) => {
       const permission = await checkEntryPermissions({
         pw: "r"
       });
-      const [entryId] = id.split("#");
+      const {
+        id: entryId
+      } = (0, _utils.parseIdentifier)(id);
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
       const originalStorageEntry = await storageOperations.entries.getRevisionById(model, {
         id
       });
@@ -837,27 +1201,25 @@ const createContentEntryCrud = params => {
         });
       }
 
-      utils.checkOwnership(context, permission, originalEntry);
+      (0, _ownership.checkOwnership)(context, permission, originalEntry);
 
       const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
         status: STATUS_REVIEW_REQUESTED
       });
 
-      let storageEntry = undefined;
+      let storageEntry = null;
 
       try {
-        await onBeforeRequestReview.publish({
+        await onBeforeEntryRequestReview.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({
+        await onAfterEntryRequestReview.publish({
           entry,
           storageEntry: result,
           model
@@ -870,11 +1232,17 @@ const createContentEntryCrud = params => {
         });
       }
     },
-    unpublishEntry: async (model, id) => {
+    unpublishEntry: async (initialModel, id) => {
       const permission = await checkEntryPermissions({
         pw: "u"
       });
-      const [entryId] = id.split("#");
+      const model = (0, _valueKeyStorageConverter.attachCmsModelFieldConverters)({
+        model: initialModel,
+        plugins
+      });
+      const {
+        id: entryId
+      } = (0, _utils.parseIdentifier)(id);
       const originalStorageEntry = await storageOperations.entries.getPublishedRevisionByEntryId(model, {
         id: entryId
       });
@@ -889,28 +1257,26 @@ const createContentEntryCrud = params => {
         });
       }
 
-      utils.checkOwnership(context, permission, originalStorageEntry);
+      (0, _ownership.checkOwnership)(context, permission, originalStorageEntry);
       const originalEntry = await (0, _entryStorage.entryFromStorageTransform)(context, model, originalStorageEntry);
 
       const entry = _objectSpread(_objectSpread({}, originalEntry), {}, {
         status: STATUS_UNPUBLISHED
       });
 
-      let storageEntry = undefined;
+      let storageEntry = null;
 
       try {
-        await onBeforeUnpublish.publish({
+        await onBeforeEntryUnpublish.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({
+        await onAfterEntryUnpublish.publish({
           entry,
           storageEntry: result,
           model