@webiny/api-headless-cms 0.0.0-unstable.990c3ab1b6 → 0.0.0-unstable.99666aeb00

package/crud/contentModel.crud.js

@@ -5,13 +5,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createModelsCrud = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _dataloader = _interopRequireDefault(require("dataloader"));
+var _error = _interopRequireDefault(require("@webiny/error"));
 var _handlerGraphql = require("@webiny/handler-graphql");
 var _contentModelManagerFactory = require("./contentModel/contentModelManagerFactory");
-var _models = require("./contentModel/models");
-var _createFieldModels = require("./contentModel/createFieldModels");
-var _error = _interopRequireDefault(require("@webiny/error"));
 var _pubsub = require("@webiny/pubsub");
 var _beforeCreate = require("./contentModel/beforeCreate");
 var _beforeUpdate = require("./contentModel/beforeUpdate");
@@ -21,49 +20,23 @@ var _afterUpdate = require("./contentModel/afterUpdate");
 var _afterDelete = require("./contentModel/afterDelete");
 var _afterCreateFrom = require("./contentModel/afterCreateFrom");
 var _CmsModelPlugin = require("../plugins/CmsModelPlugin");
-var _permissions = require("../utils/permissions");
 var _filterAsync = require("../utils/filterAsync");
-var _ownership = require("../utils/ownership");
-var _access = require("../utils/access");
-var _validateModelFields = require("./contentModel/validateModelFields");
-var _semver = _interopRequireDefault(require("semver"));
+var _validation = require("./contentModel/validation");
+var _utils = require("@webiny/utils");
+var _defaultFields = require("./contentModel/defaultFields");
+var _modelApiName = require("./contentModel/compatibility/modelApiName");
+const _excluded = ["defaultFields"];
 /**
- * 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 version = _semver.default.coerce(model.webinyVersion);
-  if (!version) {
-    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 || [];
+  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 => {
   const {
@@ -71,6 +44,7 @@ const createModelsCrud = params => {
     getIdentity,
     getLocale,
     storageOperations,
+    modelsPermissions,
     context
   } = params;
   const loaders = {
@@ -83,9 +57,15 @@ const createModelsCrud = params => {
       });
       return [models.map(model => {
         return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
-          fields: attachStorageIdToModelFields(model),
+          tags: ensureTypeTag(model),
           tenant: model.tenant || getTenant().id,
-          locale: model.locale || getLocale().code
+          locale: model.locale || getLocale().code,
+          /**
+           * TODO: remove in v5.36.0
+           * This is for backward compatibility while migrations are not yet executed.
+           */
+          singularApiName: (0, _modelApiName.ensureSingularApiName)(model),
+          pluralApiName: (0, _modelApiName.ensurePluralApiName)(model)
         });
       })];
     })
@@ -101,46 +81,37 @@ const createModelsCrud = params => {
     managers.set(model.modelId, manager);
     return manager;
   };
-  const checkModelPermissions = check => {
-    return (0, _permissions.checkPermissions)(context, "cms.contentModel", {
-      rwd: check
+  const checkModelPermissions = rwd => {
+    return modelsPermissions.ensure({
+      rwd
     });
   };
   const getModelsAsPlugins = () => {
     const tenant = getTenant().id;
     const locale = getLocale().code;
-    const models = context.plugins.byType(_CmsModelPlugin.CmsModelPlugin.type)
+    return context.plugins.byType(_CmsModelPlugin.CmsModelPlugin.type)
     /**
      * We need to filter out models that are not for this tenant or locale.
      * If it does not have tenant or locale define, it is for every locale and tenant
      */.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 (0, _objectSpread2.default)((0, _objectSpread2.default)({}, plugin.contentModel), {}, {
+        tags: ensureTypeTag(plugin.contentModel),
         tenant,
         locale,
         webinyVersion: context.WEBINY_VERSION
       });
     });
-    /**
-     * Only point where we can truly validate the user model is in the runtime.
-     */
-    for (const model of models) {
-      (0, _validateModelFields.validateModelFields)({
-        model,
-        plugins: context.plugins
-      });
-    }
-    return models;
   };
   const modelsGet = async modelId => {
     const pluginModel = getModelsAsPlugins().find(model => model.modelId === modelId);
@@ -156,6 +127,7 @@ const createModelsCrud = params => {
       throw new _handlerGraphql.NotFoundError(`Content model "${modelId}" was not found!`);
     }
     return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
+      tags: ensureTypeTag(model),
       tenant: model.tenant || getTenant().id,
       locale: model.locale || getLocale().code
     });
@@ -166,21 +138,37 @@ const createModelsCrud = params => {
     return databaseModels.concat(pluginsModels);
   };
   const listModels = async () => {
-    const permission = await checkModelPermissions("r");
-    const models = await modelsList();
-    return (0, _filterAsync.filterAsync)(models, async model => {
-      if (!(0, _ownership.validateOwnership)(context, permission, model)) {
-        return false;
-      }
-      return (0, _access.validateModelAccess)(context, model);
+    return context.benchmark.measure("headlessCms.crud.models.listModels", async () => {
+      const models = await modelsList();
+      return (0, _filterAsync.filterAsync)(models, async model => {
+        const ownsModel = await modelsPermissions.ensure({
+          owns: model.createdBy
+        }, {
+          throw: false
+        });
+        if (!ownsModel) {
+          return false;
+        }
+        return modelsPermissions.canAccessModel({
+          model,
+          locale: getLocale().code
+        });
+      });
     });
   };
   const getModel = async modelId => {
-    const permission = await checkModelPermissions("r");
-    const model = await modelsGet(modelId);
-    (0, _ownership.checkOwnership)(context, permission, model);
-    await (0, _access.checkModelAccess)(context, model);
-    return model;
+    return context.benchmark.measure("headlessCms.crud.models.getModel", async () => {
+      await checkModelPermissions("r");
+      const model = await modelsGet(modelId);
+      await modelsPermissions.ensure({
+        owns: model.createdBy
+      });
+      await modelsPermissions.ensureCanAccessModel({
+        model,
+        locale: getLocale().code
+      });
+      return model;
+    });
   };
   const getModelManager = async target => {
     const modelId = typeof target === "string" ? target : target.modelId;
@@ -195,18 +183,33 @@ const createModelsCrud = params => {
     return await updateManager(context, model);
   };
 
-  // create
+  /**
+   * Create
+   */
   const onModelBeforeCreate = (0, _pubsub.createTopic)("cms.onModelBeforeCreate");
   const onModelAfterCreate = (0, _pubsub.createTopic)("cms.onModelAfterCreate");
-  // create from
+  const onModelCreateError = (0, _pubsub.createTopic)("cms.onModelCreateError");
+  /**
+   * Create from / clone
+   */
   const onModelBeforeCreateFrom = (0, _pubsub.createTopic)("cms.onModelBeforeCreateFrom");
   const onModelAfterCreateFrom = (0, _pubsub.createTopic)("cms.onModelAfterCreateFrom");
-  // update
+  const onModelCreateFromError = (0, _pubsub.createTopic)("cms.onModelCreateFromError");
+  /**
+   * Update
+   */
   const onModelBeforeUpdate = (0, _pubsub.createTopic)("cms.onModelBeforeUpdate");
   const onModelAfterUpdate = (0, _pubsub.createTopic)("cms.onModelAfterUpdate");
-  // delete
+  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 onModelInitialize = (0, _pubsub.createTopic)("cms.onModelInitialize");
   /**
    * We need to assign some default behaviors.
@@ -214,7 +217,7 @@ const createModelsCrud = params => {
   (0, _beforeCreate.assignModelBeforeCreate)({
     onModelBeforeCreate,
     onModelBeforeCreateFrom,
-    plugins: context.plugins,
+    context,
     storageOperations
   });
   (0, _afterCreate.assignModelAfterCreate)({
@@ -223,8 +226,7 @@ const createModelsCrud = params => {
   });
   (0, _beforeUpdate.assignModelBeforeUpdate)({
     onModelBeforeUpdate,
-    plugins: context.plugins,
-    storageOperations
+    context
   });
   (0, _afterUpdate.assignModelAfterUpdate)({
     context,
@@ -243,71 +245,62 @@ const createModelsCrud = params => {
     context,
     onModelAfterDelete
   });
-  return {
-    /**
-     * Deprecated - will be removed in 5.36.0
-     */
-    onBeforeModelCreate: onModelBeforeCreate,
-    onAfterModelCreate: onModelAfterCreate,
-    onBeforeModelCreateFrom: onModelBeforeCreateFrom,
-    onAfterModelCreateFrom: onModelAfterCreateFrom,
-    onBeforeModelUpdate: onModelBeforeUpdate,
-    onAfterModelUpdate: onModelAfterUpdate,
-    onBeforeModelDelete: onModelBeforeDelete,
-    onAfterModelDelete: onModelAfterDelete,
+
+  /**
+   * CRUD methods
+   */
+  const createModel = async input => {
+    await checkModelPermissions("w");
+    const result = await (0, _validation.createModelCreateValidation)().safeParseAsync(input);
+    if (!result.success) {
+      throw (0, _utils.createZodError)(result.error);
+    }
     /**
-     * Released in 5.34.0
+     * We need to extract the defaultFields because it is not for the CmsModel object.
      */
-    onModelBeforeCreate,
-    onModelAfterCreate,
-    onModelBeforeCreateFrom,
-    onModelAfterCreateFrom,
-    onModelBeforeUpdate,
-    onModelAfterUpdate,
-    onModelBeforeDelete,
-    onModelAfterDelete,
-    onModelInitialize,
-    clearModelsCache,
-    getModel,
-    listModels,
-    async createModel(inputData) {
-      await checkModelPermissions("w");
-      const createdData = new _models.CreateContentModelModel().populate(inputData);
-      await createdData.validate();
-      const input = await createdData.toJSON();
-      context.security.disableAuthorization();
-      const group = await context.cms.getGroup(input.group);
-      context.security.enableAuthorization();
-      if (!group) {
-        throw new _handlerGraphql.NotFoundError(`There is no group "${input.group}".`);
-      }
-      const fields = await (0, _createFieldModels.createFieldModels)(input.fields);
-      const identity = getIdentity();
-      const model = {
-        name: input.name,
-        description: input.description || "",
-        modelId: input.modelId || "",
-        titleFieldId: "id",
-        locale: getLocale().code,
-        tenant: getTenant().id,
-        group: {
-          id: group.id,
-          name: group.name
-        },
-        createdBy: {
-          id: identity.id,
-          displayName: identity.displayName,
-          type: identity.type
-        },
-        createdOn: new Date().toISOString(),
-        savedOn: new Date().toISOString(),
-        fields,
-        lockedFields: [],
-        layout: input.layout || [],
-        webinyVersion: context.WEBINY_VERSION
-      };
+    const _removeUndefinedValue = (0, _utils.removeUndefinedValues)(result.data),
+      {
+        defaultFields
+      } = _removeUndefinedValue,
+      data = (0, _objectWithoutProperties2.default)(_removeUndefinedValue, _excluded);
+    if (defaultFields) {
+      (0, _defaultFields.assignModelDefaultFields)(data);
+    }
+    const group = await context.security.withoutAuthorization(async () => {
+      return context.cms.getGroup(data.group);
+    });
+    if (!group) {
+      throw new _handlerGraphql.NotFoundError(`There is no group "${data.group}".`);
+    }
+    const identity = getIdentity();
+    const model = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, data), {}, {
+      modelId: data.modelId || "",
+      singularApiName: data.singularApiName,
+      pluralApiName: data.pluralApiName,
+      titleFieldId: "id",
+      descriptionFieldId: null,
+      imageFieldId: null,
+      description: data.description || "",
+      locale: getLocale().code,
+      tenant: getTenant().id,
+      group: {
+        id: group.id,
+        name: group.name
+      },
+      createdBy: {
+        id: identity.id,
+        displayName: identity.displayName,
+        type: identity.type
+      },
+      createdOn: new Date().toISOString(),
+      savedOn: new Date().toISOString(),
+      lockedFields: [],
+      webinyVersion: context.WEBINY_VERSION
+    });
+    model.tags = ensureTypeTag(model);
+    try {
       await onModelBeforeCreate.publish({
-        input,
+        input: data,
         model
       });
       const createdModel = await storageOperations.models.create({
@@ -316,25 +309,101 @@ const createModelsCrud = params => {
       loaders.listModels.clearAll();
       await updateManager(context, model);
       await onModelAfterCreate.publish({
-        input,
+        input: data,
         model: createdModel
       });
       return createdModel;
-    },
-    /**
-     * Method does not check for permissions or ownership.
-     * @internal
-     */
-    async updateModelDirect(params) {
-      const {
-        model: initialModel,
-        original
-      } = params;
-      const model = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, initialModel), {}, {
-        tenant: initialModel.tenant || getTenant().id,
-        locale: initialModel.locale || getLocale().code,
-        webinyVersion: context.WEBINY_VERSION
+    } catch (ex) {
+      await onModelCreateError.publish({
+        input: data,
+        model,
+        error: ex
+      });
+      throw ex;
+    }
+  };
+  const updateModel = async (modelId, input) => {
+    await checkModelPermissions("w");
+
+    // Get a model record; this will also perform ownership validation.
+    const original = await getModel(modelId);
+    const result = await (0, _validation.createModelUpdateValidation)().safeParseAsync(input);
+    if (!result.success) {
+      throw (0, _utils.createZodError)(result.error);
+    }
+    const data = (0, _utils.removeUndefinedValues)(result.data);
+    if (Object.keys(data).length === 0) {
+      /**
+       * We need to return the original if nothing is to be updated.
+       */
+      return original;
+    }
+    let group = {
+      id: original.group.id,
+      name: original.group.name
+    };
+    const groupId = data.group;
+    if (groupId) {
+      const groupData = await context.security.withoutAuthorization(async () => {
+        return context.cms.getGroup(groupId);
+      });
+      if (!groupData) {
+        throw new _handlerGraphql.NotFoundError(`There is no group "${groupId}".`);
+      }
+      group = {
+        id: groupData.id,
+        name: groupData.name
+      };
+    }
+    const model = (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, original), data), {}, {
+      titleFieldId: data.titleFieldId === undefined ? original.titleFieldId : data.titleFieldId,
+      descriptionFieldId: data.descriptionFieldId === undefined ? original.descriptionFieldId : data.descriptionFieldId,
+      imageFieldId: data.imageFieldId === undefined ? original.imageFieldId : data.imageFieldId,
+      group,
+      description: data.description || original.description,
+      tenant: original.tenant || getTenant().id,
+      locale: original.locale || getLocale().code,
+      webinyVersion: context.WEBINY_VERSION,
+      savedOn: new Date().toISOString()
+    });
+    model.tags = ensureTypeTag(model);
+    try {
+      await onModelBeforeUpdate.publish({
+        input: data,
+        original,
+        model
+      });
+      const resultModel = await storageOperations.models.update({
+        model
+      });
+      await updateManager(context, resultModel);
+      await onModelAfterUpdate.publish({
+        input: data,
+        original,
+        model: resultModel
+      });
+      return resultModel;
+    } catch (ex) {
+      await onModelUpdateError.publish({
+        input: data,
+        model,
+        original,
+        error: ex
       });
+      throw ex;
+    }
+  };
+  const updateModelDirect = async params => {
+    const {
+      model: initialModel,
+      original
+    } = params;
+    const model = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, initialModel), {}, {
+      tenant: initialModel.tenant || getTenant().id,
+      locale: initialModel.locale || getLocale().code,
+      webinyVersion: context.WEBINY_VERSION
+    });
+    try {
       await onModelBeforeUpdate.publish({
         input: {},
         original,
@@ -351,59 +420,70 @@ const createModelsCrud = params => {
         model: resultModel
       });
       return resultModel;
-    },
-    async createModelFrom(modelId, data) {
-      await checkModelPermissions("w");
-      /**
-       * Get a model record; this will also perform ownership validation.
-       */
-      const original = await getModel(modelId);
-      const createdData = new _models.CreateContentModelModelFrom().populate({
-        name: data.name,
-        modelId: data.modelId,
-        description: data.description || original.description,
-        group: data.group,
-        locale: data.locale
-      });
-      await createdData.validate();
-      const input = await createdData.toJSON();
-      const locale = await context.i18n.getLocale(input.locale || original.locale);
-      if (!locale) {
-        throw new _handlerGraphql.NotFoundError(`There is no locale "${input.locale}".`);
-      }
-      /**
-       * Use storage operations directly because we cannot get group from different locale via context methods.
-       */
-      const group = await context.cms.storageOperations.groups.get({
-        id: input.group,
-        tenant: original.tenant,
-        locale: locale.code
-      });
-      if (!group) {
-        throw new _handlerGraphql.NotFoundError(`There is no group "${input.group}".`);
-      }
-      const identity = getIdentity();
-      const model = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, original), {}, {
-        locale: locale.code,
-        group: {
-          id: group.id,
-          name: group.name
-        },
-        name: input.name,
-        modelId: input.modelId || "",
-        description: input.description || "",
-        createdBy: {
-          id: identity.id,
-          displayName: identity.displayName,
-          type: identity.type
-        },
-        createdOn: new Date().toISOString(),
-        savedOn: new Date().toISOString(),
-        lockedFields: [],
-        webinyVersion: context.WEBINY_VERSION
+    } catch (ex) {
+      await onModelUpdateError.publish({
+        input: {},
+        original,
+        model,
+        error: ex
       });
+      throw ex;
+    }
+  };
+  const createModelFrom = async (modelId, input) => {
+    await checkModelPermissions("w");
+    /**
+     * Get a model record; this will also perform ownership validation.
+     */
+    const original = await getModel(modelId);
+    const result = await (0, _validation.createModelCreateFromValidation)().safeParseAsync((0, _objectSpread2.default)((0, _objectSpread2.default)({}, input), {}, {
+      description: input.description || original.description
+    }));
+    if (!result.success) {
+      throw (0, _utils.createZodError)(result.error);
+    }
+    const data = (0, _utils.removeUndefinedValues)(result.data);
+    const locale = await context.i18n.getLocale(data.locale || original.locale);
+    if (!locale) {
+      throw new _handlerGraphql.NotFoundError(`There is no locale "${data.locale}".`);
+    }
+    /**
+     * Use storage operations directly because we cannot get group from different locale via context methods.
+     */
+    const group = await context.cms.storageOperations.groups.get({
+      id: data.group,
+      tenant: original.tenant,
+      locale: locale.code
+    });
+    if (!group) {
+      throw new _handlerGraphql.NotFoundError(`There is no group "${data.group}".`);
+    }
+    const identity = getIdentity();
+    const model = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, original), {}, {
+      singularApiName: data.singularApiName,
+      pluralApiName: data.pluralApiName,
+      locale: locale.code,
+      group: {
+        id: group.id,
+        name: group.name
+      },
+      icon: data.icon,
+      name: data.name,
+      modelId: data.modelId || "",
+      description: data.description || "",
+      createdBy: {
+        id: identity.id,
+        displayName: identity.displayName,
+        type: identity.type
+      },
+      createdOn: new Date().toISOString(),
+      savedOn: new Date().toISOString(),
+      lockedFields: [],
+      webinyVersion: context.WEBINY_VERSION
+    });
+    try {
       await onModelBeforeCreateFrom.publish({
-        input,
+        input: data,
         model,
         original
       });
@@ -413,72 +493,25 @@ const createModelsCrud = params => {
       loaders.listModels.clearAll();
       await updateManager(context, model);
       await onModelAfterCreateFrom.publish({
-        input,
+        input: data,
         original,
         model: createdModel
       });
       return createdModel;
-    },
-    async updateModel(modelId, inputData) {
-      await checkModelPermissions("w");
-
-      // Get a model record; this will also perform ownership validation.
-      const original = await getModel(modelId);
-      const updatedData = new _models.UpdateContentModelModel().populate(inputData);
-      await updatedData.validate();
-      const input = await updatedData.toJSON({
-        onlyDirty: true
-      });
-      if (Object.keys(input).length === 0) {
-        /**
-         * We need to return the original if nothing is to be updated.
-         */
-        return original;
-      }
-      let group = {
-        id: original.group.id,
-        name: original.group.name
-      };
-      if (input.group) {
-        context.security.disableAuthorization();
-        const groupData = await context.cms.getGroup(input.group);
-        context.security.enableAuthorization();
-        if (!groupData) {
-          throw new _handlerGraphql.NotFoundError(`There is no group "${input.group}".`);
-        }
-        group = {
-          id: groupData.id,
-          name: groupData.name
-        };
-      }
-      const fields = await (0, _createFieldModels.createFieldModels)(inputData.fields);
-      const model = (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, original), input), {}, {
-        group,
-        tenant: original.tenant || getTenant().id,
-        locale: original.locale || getLocale().code,
-        webinyVersion: context.WEBINY_VERSION,
-        fields,
-        savedOn: new Date().toISOString()
-      });
-      await onModelBeforeUpdate.publish({
-        input,
-        original,
-        model
-      });
-      const resultModel = await storageOperations.models.update({
-        model
-      });
-      await updateManager(context, resultModel);
-      await onModelAfterUpdate.publish({
-        input,
+    } catch (ex) {
+      await onModelCreateFromError.publish({
+        input: data,
         original,
-        model: resultModel
+        model,
+        error: ex
       });
-      return resultModel;
-    },
-    async deleteModel(modelId) {
-      await checkModelPermissions("d");
-      const model = await getModel(modelId);
+      throw ex;
+    }
+  };
+  const deleteModel = async modelId => {
+    await checkModelPermissions("d");
+    const model = await getModel(modelId);
+    try {
       await onModelBeforeDelete.publish({
         model
       });
@@ -496,18 +529,91 @@ const createModelsCrud = params => {
         model
       });
       managers.delete(model.modelId);
+    } catch (ex) {
+      await onModelDeleteError.publish({
+        model,
+        error: ex
+      });
+      throw ex;
+    }
+  };
+  const initializeModel = async (modelId, data) => {
+    /**
+     * We require that users have write permissions to initialize models.
+     * Maybe introduce another permission for it?
+     */
+    await checkModelPermissions("w");
+    const model = await getModel(modelId);
+    await onModelInitialize.publish({
+      model,
+      data
+    });
+    return true;
+  };
+  return {
+    /**
+     * 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,
+    listModels,
+    async createModel(input) {
+      return context.benchmark.measure("headlessCms.crud.models.createModel", async () => {
+        return createModel(input);
+      });
     },
-    async initializeModel(modelId) {
-      /**
-       * We require that users have write permissions to initialize models.
-       * Maybe introduce another permission for it?
-       */
-      await checkModelPermissions("w");
-      const model = await getModel(modelId);
-      await onModelInitialize.publish({
-        model
+    /**
+     * Method does not check for permissions or ownership.
+     * @internal
+     */
+    async updateModelDirect(params) {
+      return context.benchmark.measure("headlessCms.crud.models.updateModelDirect", async () => {
+        return updateModelDirect(params);
+      });
+    },
+    async createModelFrom(modelId, userInput) {
+      return context.benchmark.measure("headlessCms.crud.models.createModelFrom", async () => {
+        return createModelFrom(modelId, userInput);
+      });
+    },
+    async updateModel(modelId, input) {
+      return context.benchmark.measure("headlessCms.crud.models.updateModel", async () => {
+        return updateModel(modelId, input);
+      });
+    },
+    async deleteModel(modelId) {
+      return context.benchmark.measure("headlessCms.crud.models.deleteModel", async () => {
+        return deleteModel(modelId);
+      });
+    },
+    async initializeModel(modelId, data) {
+      return context.benchmark.measure("headlessCms.crud.models.initializeModel", async () => {
+        return initializeModel(modelId, data);
       });
-      return true;
     },
     getModelManager,
     getEntryManager: async model => {