@webiny/api-headless-cms 5.33.5 → 5.34.0-beta.1

package/crud/contentModel.crud.js

@@ -1,13 +1,13 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createModelsCrud = void 0;
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
 var _dataloader = _interopRequireDefault(require("dataloader"));
 
@@ -49,60 +49,19 @@ var _access = require("../utils/access");
 
 var _validateModelFields = require("./contentModel/validateModelFields");
 
-var _semver = _interopRequireDefault(require("semver"));
-
-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; }
-
 /**
- * TODO: remove for 5.34.0
- * Required because of the 5.33.0 upgrade.
- * Until the upgrade is done, API will break because there is no storageId assigned.
+ * Given a model, return an array of tags ensuring the `type` tag is set.
  */
-const featureVersion = _semver.default.coerce("5.33.0");
-
-const attachStorageIdToFields = fields => {
-  return fields.map(field => {
-    var _field$settings;
-
-    if ((_field$settings = field.settings) !== null && _field$settings !== void 0 && _field$settings.fields) {
-      field.settings.fields = attachStorageIdToFields(field.settings.fields);
-    }
-
-    if (!field.storageId) {
-      field.storageId = field.fieldId;
-    }
-
-    return field;
-  });
-};
-
-const attachStorageIdToModelFields = model => {
-  if (!model.webinyVersion) {
-    return model.fields;
-  }
+const ensureTypeTag = model => {
+  // Let's make sure we have a `type` tag assigned.
+  // If `type` tag is not set, set it to a default one (`model`).
+  const tags = model.tags || [];
 
-  const version = _semver.default.coerce(model.webinyVersion);
-
-  if (!version) {
-    return model.fields;
+  if (!tags.some(tag => tag.startsWith("type:"))) {
+    tags.push("type:model");
   }
-  /**
-   * Unfortunately we need to check for beta and next.
-   * TODO remove after 5.33.0
-   */
-
 
-  if (model.webinyVersion.match(/beta|next/)) {
-    return attachStorageIdToFields(model.fields);
-  }
-
-  if (_semver.default.compare(version, featureVersion) >= 0) {
-    return model.fields;
-  }
-
-  return attachStorageIdToFields(model.fields);
+  return tags;
 };
 
 const createModelsCrud = params => {
@@ -122,8 +81,8 @@ const createModelsCrud = params => {
         }
       });
       return [models.map(model => {
-        return _objectSpread(_objectSpread({}, model), {}, {
-          fields: attachStorageIdToModelFields(model),
+        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
+          tags: ensureTypeTag(model),
           tenant: model.tenant || getTenant().id,
           locale: model.locale || getLocale().code
         });
@@ -161,19 +120,20 @@ const createModelsCrud = params => {
      */
     .filter(plugin => {
       const {
-        tenant: t,
-        locale: l
+        tenant: modelTenant,
+        locale: modelLocale
       } = plugin.contentModel;
 
-      if (t && t !== tenant) {
+      if (modelTenant && modelTenant !== tenant) {
         return false;
-      } else if (l && l !== locale) {
+      } else if (modelLocale && modelLocale !== locale) {
         return false;
       }
 
       return true;
     }).map(plugin => {
-      return _objectSpread(_objectSpread({}, plugin.contentModel), {}, {
+      return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, plugin.contentModel), {}, {
+        tags: ensureTypeTag(plugin.contentModel),
         tenant,
         locale,
         webinyVersion: context.WEBINY_VERSION
@@ -210,7 +170,8 @@ const createModelsCrud = params => {
       throw new _handlerGraphql.NotFoundError(`Content model "${modelId}" was not found!`);
     }
 
-    return _objectSpread(_objectSpread({}, model), {}, {
+    return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
+      tags: ensureTypeTag(model),
       tenant: model.tenant || getTenant().id,
       locale: model.locale || getLocale().code
     });
@@ -258,61 +219,104 @@ const createModelsCrud = params => {
 
     return await updateManager(context, model);
   };
+  /**
+   * Create
+   */
+
+
+  const onModelBeforeCreate = (0, _pubsub.createTopic)("cms.onModelBeforeCreate");
+  const onModelAfterCreate = (0, _pubsub.createTopic)("cms.onModelAfterCreate");
+  const onModelCreateError = (0, _pubsub.createTopic)("cms.onModelCreateError");
+  /**
+   * Create from / clone
+   */
+
+  const onModelBeforeCreateFrom = (0, _pubsub.createTopic)("cms.onModelBeforeCreateFrom");
+  const onModelAfterCreateFrom = (0, _pubsub.createTopic)("cms.onModelAfterCreateFrom");
+  const onModelCreateFromError = (0, _pubsub.createTopic)("cms.onModelCreateFromError");
+  /**
+   * Update
+   */
+
+  const onModelBeforeUpdate = (0, _pubsub.createTopic)("cms.onModelBeforeUpdate");
+  const onModelAfterUpdate = (0, _pubsub.createTopic)("cms.onModelAfterUpdate");
+  const onModelUpdateError = (0, _pubsub.createTopic)("cms.onModelUpdateError");
+  /**
+   * Delete
+   */
+
+  const onModelBeforeDelete = (0, _pubsub.createTopic)("cms.onModelBeforeDelete");
+  const onModelAfterDelete = (0, _pubsub.createTopic)("cms.onModelAfterDelete");
+  const onModelDeleteError = (0, _pubsub.createTopic)("cms.onModelDeleteError");
+  /**
+   * Initialize
+   */
 
-  const onBeforeModelCreate = (0, _pubsub.createTopic)();
-  const onAfterModelCreate = (0, _pubsub.createTopic)();
-  const onBeforeModelCreateFrom = (0, _pubsub.createTopic)();
-  const onAfterModelCreateFrom = (0, _pubsub.createTopic)();
-  const onBeforeModelUpdate = (0, _pubsub.createTopic)();
-  const onAfterModelUpdate = (0, _pubsub.createTopic)();
-  const onBeforeModelDelete = (0, _pubsub.createTopic)();
-  const onAfterModelDelete = (0, _pubsub.createTopic)();
   const onModelInitialize = (0, _pubsub.createTopic)("cms.onModelInitialize");
   /**
    * We need to assign some default behaviors.
    */
 
-  (0, _beforeCreate.assignBeforeModelCreate)({
-    onBeforeModelCreate,
-    onBeforeModelCreateFrom,
+  (0, _beforeCreate.assignModelBeforeCreate)({
+    onModelBeforeCreate,
+    onModelBeforeCreateFrom,
     plugins: context.plugins,
     storageOperations
   });
-  (0, _afterCreate.assignAfterModelCreate)({
+  (0, _afterCreate.assignModelAfterCreate)({
     context,
-    onAfterModelCreate
+    onModelAfterCreate
   });
-  (0, _beforeUpdate.assignBeforeModelUpdate)({
-    onBeforeModelUpdate,
+  (0, _beforeUpdate.assignModelBeforeUpdate)({
+    onModelBeforeUpdate,
     plugins: context.plugins,
     storageOperations
   });
-  (0, _afterUpdate.assignAfterModelUpdate)({
+  (0, _afterUpdate.assignModelAfterUpdate)({
     context,
-    onAfterModelUpdate
+    onModelAfterUpdate
   });
-  (0, _afterCreateFrom.assignAfterModelCreateFrom)({
+  (0, _afterCreateFrom.assignModelAfterCreateFrom)({
     context,
-    onAfterModelCreateFrom
+    onModelAfterCreateFrom
   });
-  (0, _beforeDelete.assignBeforeModelDelete)({
-    onBeforeModelDelete,
+  (0, _beforeDelete.assignModelBeforeDelete)({
+    onModelBeforeDelete,
     plugins: context.plugins,
     storageOperations
   });
-  (0, _afterDelete.assignAfterModelDelete)({
+  (0, _afterDelete.assignModelAfterDelete)({
     context,
-    onAfterModelDelete
+    onModelAfterDelete
   });
   return {
-    onBeforeModelCreate,
-    onAfterModelCreate,
-    onBeforeModelCreateFrom,
-    onAfterModelCreateFrom,
-    onBeforeModelUpdate,
-    onAfterModelUpdate,
-    onBeforeModelDelete,
-    onAfterModelDelete,
+    /**
+     * Deprecated - will be removed in 5.36.0
+     */
+    onBeforeModelCreate: onModelBeforeCreate,
+    onAfterModelCreate: onModelAfterCreate,
+    onBeforeModelCreateFrom: onModelBeforeCreateFrom,
+    onAfterModelCreateFrom: onModelAfterCreateFrom,
+    onBeforeModelUpdate: onModelBeforeUpdate,
+    onAfterModelUpdate: onModelAfterUpdate,
+    onBeforeModelDelete: onModelBeforeDelete,
+    onAfterModelDelete: onModelAfterDelete,
+
+    /**
+     * Released in 5.34.0
+     */
+    onModelBeforeCreate,
+    onModelAfterCreate,
+    onModelCreateError,
+    onModelBeforeCreateFrom,
+    onModelAfterCreateFrom,
+    onModelCreateFromError,
+    onModelBeforeUpdate,
+    onModelAfterUpdate,
+    onModelUpdateError,
+    onModelBeforeDelete,
+    onModelAfterDelete,
+    onModelDeleteError,
     onModelInitialize,
     clearModelsCache,
     getModel,
@@ -354,22 +358,34 @@ const createModelsCrud = params => {
         fields,
         lockedFields: [],
         layout: input.layout || [],
+        tags: [...(input.tags || [])],
         webinyVersion: context.WEBINY_VERSION
       };
-      await onBeforeModelCreate.publish({
-        input,
-        model
-      });
-      const createdModel = await storageOperations.models.create({
-        model
-      });
-      loaders.listModels.clearAll();
-      await updateManager(context, model);
-      await onAfterModelCreate.publish({
-        input,
-        model: createdModel
-      });
-      return createdModel;
+      model.tags = ensureTypeTag(model);
+
+      try {
+        await onModelBeforeCreate.publish({
+          input,
+          model
+        });
+        const createdModel = await storageOperations.models.create({
+          model
+        });
+        loaders.listModels.clearAll();
+        await updateManager(context, model);
+        await onModelAfterCreate.publish({
+          input,
+          model: createdModel
+        });
+        return createdModel;
+      } catch (ex) {
+        await onModelCreateError.publish({
+          input,
+          model,
+          error: ex
+        });
+        throw ex;
+      }
     },
 
     /**
@@ -381,29 +397,38 @@ const createModelsCrud = params => {
         model: initialModel,
         original
       } = params;
-
-      const model = _objectSpread(_objectSpread({}, initialModel), {}, {
+      const model = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, initialModel), {}, {
         tenant: initialModel.tenant || getTenant().id,
         locale: initialModel.locale || getLocale().code,
         webinyVersion: context.WEBINY_VERSION
       });
 
-      await onBeforeModelUpdate.publish({
-        input: {},
-        original,
-        model
-      });
-      const resultModel = await storageOperations.models.update({
-        model
-      });
-      await updateManager(context, resultModel);
-      loaders.listModels.clearAll();
-      await onAfterModelUpdate.publish({
-        input: {},
-        original,
-        model: resultModel
-      });
-      return resultModel;
+      try {
+        await onModelBeforeUpdate.publish({
+          input: {},
+          original,
+          model
+        });
+        const resultModel = await storageOperations.models.update({
+          model
+        });
+        await updateManager(context, resultModel);
+        loaders.listModels.clearAll();
+        await onModelAfterUpdate.publish({
+          input: {},
+          original,
+          model: resultModel
+        });
+        return resultModel;
+      } catch (ex) {
+        await onModelUpdateError.publish({
+          input: {},
+          original,
+          model,
+          error: ex
+        });
+        throw ex;
+      }
     },
 
     async createModelFrom(modelId, data) {
@@ -443,8 +468,7 @@ const createModelsCrud = params => {
       }
 
       const identity = getIdentity();
-
-      const model = _objectSpread(_objectSpread({}, original), {}, {
+      const model = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, original), {}, {
         locale: locale.code,
         group: {
           id: group.id,
@@ -464,22 +488,32 @@ const createModelsCrud = params => {
         webinyVersion: context.WEBINY_VERSION
       });
 
-      await onBeforeModelCreateFrom.publish({
-        input,
-        model,
-        original
-      });
-      const createdModel = await storageOperations.models.create({
-        model
-      });
-      loaders.listModels.clearAll();
-      await updateManager(context, model);
-      await onAfterModelCreateFrom.publish({
-        input,
-        original,
-        model: createdModel
-      });
-      return createdModel;
+      try {
+        await onModelBeforeCreateFrom.publish({
+          input,
+          model,
+          original
+        });
+        const createdModel = await storageOperations.models.create({
+          model
+        });
+        loaders.listModels.clearAll();
+        await updateManager(context, model);
+        await onModelAfterCreateFrom.publish({
+          input,
+          original,
+          model: createdModel
+        });
+        return createdModel;
+      } catch (ex) {
+        await onModelCreateFromError.publish({
+          input,
+          original,
+          model,
+          error: ex
+        });
+        throw ex;
+      }
     },
 
     async updateModel(modelId, inputData) {
@@ -520,8 +554,7 @@ const createModelsCrud = params => {
       }
 
       const fields = await (0, _createFieldModels.createFieldModels)(inputData.fields);
-
-      const model = _objectSpread(_objectSpread(_objectSpread({}, original), input), {}, {
+      const model = (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, original), input), {}, {
         group,
         tenant: original.tenant || getTenant().id,
         locale: original.locale || getLocale().code,
@@ -529,46 +562,66 @@ const createModelsCrud = params => {
         fields,
         savedOn: new Date().toISOString()
       });
+      model.tags = ensureTypeTag(model);
 
-      await onBeforeModelUpdate.publish({
-        input,
-        original,
-        model
-      });
-      const resultModel = await storageOperations.models.update({
-        model
-      });
-      await updateManager(context, resultModel);
-      await onAfterModelUpdate.publish({
-        input,
-        original,
-        model: resultModel
-      });
-      return resultModel;
+      try {
+        await onModelBeforeUpdate.publish({
+          input,
+          original,
+          model
+        });
+        const resultModel = await storageOperations.models.update({
+          model
+        });
+        await updateManager(context, resultModel);
+        await onModelAfterUpdate.publish({
+          input,
+          original,
+          model: resultModel
+        });
+        return resultModel;
+      } catch (ex) {
+        await onModelUpdateError.publish({
+          input,
+          model,
+          original,
+          error: ex
+        });
+        throw ex;
+      }
     },
 
     async deleteModel(modelId) {
       await checkModelPermissions("d");
       const model = await getModel(modelId);
-      await onBeforeModelDelete.publish({
-        model
-      });
 
       try {
-        await storageOperations.models.delete({
+        await onModelBeforeDelete.publish({
+          model
+        });
+
+        try {
+          await storageOperations.models.delete({
+            model
+          });
+        } catch (ex) {
+          throw new _error.default(ex.message || "Could not delete the content model", ex.code || "CONTENT_MODEL_DELETE_ERROR", {
+            error: ex,
+            modelId: model.modelId
+          });
+        }
+
+        await onModelAfterDelete.publish({
           model
         });
+        managers.delete(model.modelId);
       } catch (ex) {
-        throw new _error.default(ex.message || "Could not delete the content model", ex.code || "CONTENT_MODEL_DELETE_ERROR", {
-          error: ex,
-          modelId: model.modelId
+        await onModelDeleteError.publish({
+          model,
+          error: ex
         });
+        throw ex;
       }
-
-      await onAfterModelDelete.publish({
-        model
-      });
-      managers.delete(model.modelId);
     },
 
     async initializeModel(modelId, data) {