@webiny/api-headless-cms 6.0.0-beta.0 → 6.0.0-rc.1

package/crud/contentModel.crud.js

@@ -1,108 +1,25 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createModelsCrud = void 0;
-var _error = _interopRequireDefault(require("@webiny/error"));
-var _handlerGraphql = require("@webiny/handler-graphql");
-var _contentModelManagerFactory = require("./contentModel/contentModelManagerFactory");
-var _pubsub = require("@webiny/pubsub");
-var _beforeCreate = require("./contentModel/beforeCreate");
-var _beforeUpdate = require("./contentModel/beforeUpdate");
-var _beforeDelete = require("./contentModel/beforeDelete");
-var _CmsModelPlugin = require("../plugins/CmsModelPlugin");
-var _validation = require("./contentModel/validation");
-var _utils = require("@webiny/utils");
-var _defaultFields = require("./contentModel/defaultFields");
-var _utils2 = require("../utils");
-var _ensureTypeTag = require("./contentModel/ensureTypeTag");
-var _listModelsFromDatabase = require("./contentModel/listModelsFromDatabase");
-var _filterAsync = require("../utils/filterAsync");
-var _contentModelAst = require("../utils/contentModelAst");
-const createModelsCrud = params => {
+import WebinyError from "@webiny/error";
+import { CreateModelUseCase } from "../features/contentModel/CreateModel/index.js";
+import { CreateModelFromUseCase } from "../features/contentModel/CreateModelFrom/index.js";
+import { UpdateModelUseCase } from "../features/contentModel/UpdateModel/index.js";
+import { DeleteModelUseCase } from "../features/contentModel/DeleteModel/index.js";
+import { GetModelUseCase } from "../features/contentModel/GetModel/index.js";
+import { ListModelsUseCase } from "../features/contentModel/ListModels/index.js";
+import { createMemoryCache } from "../utils/index.js";
+import { CmsModelFieldToAstConverterFromPlugins, CmsModelToAstConverter } from "../utils/contentModelAst/index.js";
+export const createModelsCrud = params => {
   const {
-    getTenant,
-    getIdentity,
-    getLocale,
-    storageOperations,
-    accessControl,
     context
   } = params;
-  const listPluginModelsCache = (0, _utils2.createMemoryCache)();
-  const listFilteredModelsCache = (0, _utils2.createMemoryCache)();
-  const listDatabaseModelsCache = (0, _utils2.createMemoryCache)();
+  const listFilteredModelsCache = createMemoryCache();
+  const listDatabaseModelsCache = createMemoryCache();
   const clearModelsCache = () => {
     listDatabaseModelsCache.clear();
     listFilteredModelsCache.clear();
   };
-  const managers = new Map();
-  const updateManager = async (context, model) => {
-    const manager = await (0, _contentModelManagerFactory.contentModelManagerFactory)(context, model);
-    managers.set(model.modelId, manager);
-    return manager;
-  };
   const fieldTypePlugins = context.plugins.byType("cms-model-field-to-graphql");
   const getModelToAstConverter = () => {
-    return new _contentModelAst.CmsModelToAstConverter(new _contentModelAst.CmsModelFieldToAstConverterFromPlugins(fieldTypePlugins));
-  };
-  const listPluginModels = async (tenant, locale) => {
-    const modelPlugins = context.plugins.byType(_CmsModelPlugin.CmsModelPlugin.type);
-    const cacheKey = (0, _utils2.createCacheKey)({
-      tenant,
-      locale,
-      models: modelPlugins.map(({
-        contentModel: model
-      }) => {
-        return `${model.modelId}#${model.pluralApiName}#${model.singularApiName}#${model.savedOn || "unknown"}`;
-      }).join("/"),
-      identity: context.security.isAuthorizationEnabled() ? getIdentity()?.id : undefined
-    });
-    return listPluginModelsCache.getOrSet(cacheKey, async () => {
-      const models = modelPlugins
-      /**
-       * 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: modelTenant,
-          locale: modelLocale
-        } = plugin.contentModel;
-        if (modelTenant && modelTenant !== tenant) {
-          return false;
-        } else if (modelLocale && modelLocale !== locale) {
-          return false;
-        }
-        return true;
-      }).map(plugin => {
-        return {
-          ...plugin.contentModel,
-          tags: (0, _ensureTypeTag.ensureTypeTag)(plugin.contentModel),
-          tenant,
-          locale,
-          webinyVersion: context.WEBINY_VERSION
-        };
-      });
-      return (0, _filterAsync.filterAsync)(models, async model => {
-        return accessControl.canAccessModel({
-          model
-        });
-      });
-    });
-  };
-  const getModelFromCache = async modelId => {
-    const models = await listModels();
-    const model = models.find(m => m.modelId === modelId);
-    if (!model) {
-      throw new _handlerGraphql.NotFoundError(`Content model "${modelId}" was not found!`);
-    }
-    return {
-      ...model,
-      tags: (0, _ensureTypeTag.ensureTypeTag)(model),
-      tenant: model.tenant || getTenant().id,
-      locale: model.locale || getLocale().code
-    };
+    return new CmsModelToAstConverter(new CmsModelFieldToAstConverterFromPlugins(fieldTypePlugins));
   };
 
   /**
@@ -111,449 +28,68 @@ const createModelsCrud = params => {
    * We always fetch the plugins and database models separately.
    * Then we combine them and run access filtering on them
    */
-  const listModels = async () => {
+  const listModels = async input => {
     return context.benchmark.measure("headlessCms.crud.models.listModels", async () => {
-      /**
-       * Maybe we can cache based on permissions, not the identity id?
-       *
-       * TODO: @adrian please check if possible.
-       */
-      const tenant = getTenant().id;
-      const locale = getLocale().code;
-      const pluginModels = await listPluginModels(tenant, locale);
-      const dbCacheKey = (0, _utils2.createCacheKey)({
-        tenant,
-        locale
-      });
-      const databaseModels = await listDatabaseModelsCache.getOrSet(dbCacheKey, async () => {
-        return await (0, _listModelsFromDatabase.listModelsFromDatabase)(params);
-      });
-      const filteredCacheKey = (0, _utils2.createCacheKey)({
-        dbCacheKey: dbCacheKey.get(),
-        identity: context.security.isAuthorizationEnabled() ? getIdentity()?.id : undefined
-      });
-      const filteredModels = await listFilteredModelsCache.getOrSet(filteredCacheKey, async () => {
-        return (0, _filterAsync.filterAsync)(databaseModels, async model => {
-          return accessControl.canAccessModel({
-            model
-          });
-        });
-      });
-      return filteredModels.concat(pluginModels);
+      // Delegate to new ListModels use case
+      const useCase = context.container.resolve(ListModelsUseCase);
+      const result = await useCase.execute(input);
+      if (result.isFail()) {
+        throw new WebinyError(result.error.message, result.error.code, result.error.data);
+      }
+      return result.value;
     });
   };
   const getModel = async modelId => {
     return context.benchmark.measure("headlessCms.crud.models.getModel", async () => {
-      const model = await context.security.withoutAuthorization(async () => {
-        return await getModelFromCache(modelId);
-      });
-      if (!model) {
-        throw new _handlerGraphql.NotFoundError(`Content model "${modelId}" was not found!`);
+      // Delegate to new GetModel use case
+      const useCase = context.container.resolve(GetModelUseCase);
+      const result = await useCase.execute(modelId);
+      if (result.isFail()) {
+        throw new WebinyError(result.error.message, result.error.code, result.error.data);
       }
-      await accessControl.ensureCanAccessModel({
-        model
-      });
-      return model;
+      return result.value;
     });
   };
-  const getEntryManager = async target => {
-    const modelId = typeof target === "string" ? target : target.modelId;
-    if (managers.has(modelId)) {
-      return managers.get(modelId);
-    }
-    const model = await getModelFromCache(modelId);
-    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 onModelInitialize = (0, _pubsub.createTopic)("cms.onModelInitialize");
-  /**
-   * We need to assign some default behaviors.
-   */
-  (0, _beforeCreate.assignModelBeforeCreate)({
-    onModelBeforeCreate,
-    onModelBeforeCreateFrom,
-    context,
-    storageOperations
-  });
-  (0, _beforeUpdate.assignModelBeforeUpdate)({
-    onModelBeforeUpdate,
-    context
-  });
-  (0, _beforeDelete.assignModelBeforeDelete)({
-    onModelBeforeDelete,
-    plugins: context.plugins,
-    storageOperations
-  });
 
   /**
    * CRUD methods
    */
   const createModel = async input => {
-    await accessControl.ensureCanAccessModel({
-      rwd: "w"
-    });
-    const result = await (0, _validation.createModelCreateValidation)().safeParseAsync(input);
-    if (!result.success) {
-      throw (0, _utils.createZodError)(result.error);
-    }
-    /**
-     * We need to extract the defaultFields because it is not for the CmsModel object.
-     */
-    const {
-      defaultFields,
-      ...data
-    } = (0, _utils.removeUndefinedValues)(result.data);
-    if (defaultFields) {
-      (0, _defaultFields.assignModelDefaultFields)(data);
-    }
-    const group = await context.cms.getGroup(data.group);
-    const identity = getIdentity();
-    const model = {
-      ...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 = (0, _ensureTypeTag.ensureTypeTag)(model);
-    await accessControl.ensureCanAccessModel({
-      model,
-      rwd: "w"
-    });
-    try {
-      await onModelBeforeCreate.publish({
-        input: data,
-        model
-      });
-      const createdModel = await storageOperations.models.create({
-        model
-      });
-      clearModelsCache();
-      await updateManager(context, model);
-      await onModelAfterCreate.publish({
-        input: data,
-        model: createdModel
-      });
-      return createdModel;
-    } catch (ex) {
-      await onModelCreateError.publish({
-        input: data,
-        model,
-        error: ex
-      });
-      throw ex;
+    // Delegate to new CreateModel use case
+    const useCase = context.container.resolve(CreateModelUseCase);
+    const result = await useCase.execute(input);
+    if (result.isFail()) {
+      throw new WebinyError(result.error.message, result.error.code, result.error.data);
     }
+    return result.value;
   };
   const updateModel = async (modelId, input) => {
-    await accessControl.ensureCanAccessModel({
-      rwd: "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.cms.getGroup(groupId);
-      group = {
-        id: groupData.id,
-        name: groupData.name
-      };
-    }
-    const model = {
-      ...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()
-    };
-    await accessControl.ensureCanAccessModel({
-      model,
-      rwd: "w"
-    });
-    model.tags = (0, _ensureTypeTag.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 = {
-      ...initialModel,
-      tenant: initialModel.tenant || getTenant().id,
-      locale: initialModel.locale || getLocale().code,
-      webinyVersion: context.WEBINY_VERSION
-    };
-    try {
-      await onModelBeforeUpdate.publish({
-        input: {},
-        original,
-        model
-      });
-      const resultModel = await storageOperations.models.update({
-        model
-      });
-      await updateManager(context, resultModel);
-      clearModelsCache();
-      await onModelAfterUpdate.publish({
-        input: {},
-        original,
-        model: resultModel
-      });
-      return resultModel;
-    } catch (ex) {
-      await onModelUpdateError.publish({
-        input: {},
-        original,
-        model,
-        error: ex
-      });
-      throw ex;
+    // Delegate to new UpdateModel use case
+    const useCase = context.container.resolve(UpdateModelUseCase);
+    const result = await useCase.execute(modelId, input);
+    if (result.isFail()) {
+      throw new WebinyError(result.error.message, result.error.code, result.error.data);
     }
+    return result.value;
   };
   const createModelFrom = async (modelId, input) => {
-    await accessControl.ensureCanAccessModel({
-      rwd: "w"
-    });
-
-    /**
-     * Get a model record; this will also perform ownership validation.
-     */
-    const original = await getModel(modelId);
-    const result = await (0, _validation.createModelCreateFromValidation)().safeParseAsync({
-      ...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 = {
-      ...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
-    };
-    await accessControl.ensureCanAccessModel({
-      model,
-      rwd: "w"
-    });
-    try {
-      await onModelBeforeCreateFrom.publish({
-        input: data,
-        model,
-        original
-      });
-      const createdModel = await storageOperations.models.create({
-        model
-      });
-      clearModelsCache();
-      await updateManager(context, model);
-      await onModelAfterCreateFrom.publish({
-        input: data,
-        original,
-        model: createdModel
-      });
-      return createdModel;
-    } catch (ex) {
-      await onModelCreateFromError.publish({
-        input: data,
-        original,
-        model,
-        error: ex
-      });
-      throw ex;
+    // Delegate to new CreateModelFrom use case
+    const useCase = context.container.resolve(CreateModelFromUseCase);
+    const result = await useCase.execute(modelId, input);
+    if (result.isFail()) {
+      throw new WebinyError(result.error.message, result.error.code, result.error.data);
     }
+    return result.value;
   };
   const deleteModel = async modelId => {
-    await accessControl.ensureCanAccessModel({
-      rwd: "d"
-    });
-    const model = await getModel(modelId);
-    await accessControl.ensureCanAccessModel({
-      model,
-      rwd: "d"
-    });
-    try {
-      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
-        });
-      }
-      clearModelsCache();
-      await onModelAfterDelete.publish({
-        model
-      });
-      managers.delete(model.modelId);
-    } catch (ex) {
-      await onModelDeleteError.publish({
-        model,
-        error: ex
-      });
-      throw ex;
+    // Delegate to new DeleteModel use case
+    const useCase = context.container.resolve(DeleteModelUseCase);
+    const result = await useCase.execute(modelId);
+    if (result.isFail()) {
+      throw new WebinyError(result.error.message, result.error.code, result.error.data);
     }
   };
-  const initializeModel = async (modelId, data) => {
-    /**
-     * We require that users have write permissions to initialize models.
-     * Maybe introduce another permission for it?
-     */
-    const model = await getModel(modelId);
-    await accessControl.ensureCanAccessModel({
-      model,
-      rwd: "w"
-    });
-    await onModelInitialize.publish({
-      model,
-      data
-    });
-    return true;
-  };
   return {
-    onModelBeforeCreate,
-    onModelAfterCreate,
-    onModelCreateError,
-    onModelBeforeCreateFrom,
-    onModelAfterCreateFrom,
-    onModelCreateFromError,
-    onModelBeforeUpdate,
-    onModelAfterUpdate,
-    onModelUpdateError,
-    onModelBeforeDelete,
-    onModelAfterDelete,
-    onModelDeleteError,
-    onModelInitialize,
     clearModelsCache,
     getModel,
     getModelToAstConverter,
@@ -563,15 +99,6 @@ const createModelsCrud = params => {
         return createModel(input);
       });
     },
-    /**
-     * 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);
@@ -586,16 +113,8 @@ const createModelsCrud = params => {
       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);
-      });
-    },
-    getEntryManager,
-    getEntryManagers: () => managers
+    }
   };
 };
-exports.createModelsCrud = createModelsCrud;
 
 //# sourceMappingURL=contentModel.crud.js.map