@webiny/api-headless-cms 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/crud/contentModel.crud.js

@@ -1,616 +1,77 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-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 _pubsub = require("@webiny/pubsub");
-var _beforeCreate = require("./contentModel/beforeCreate");
-var _beforeUpdate = require("./contentModel/beforeUpdate");
-var _beforeDelete = require("./contentModel/beforeDelete");
-var _afterCreate = require("./contentModel/afterCreate");
-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 _validation = require("./contentModel/validation");
-var _utils = require("@webiny/utils");
-var _defaultFields = require("./contentModel/defaultFields");
-var _modelApiName = require("./contentModel/compatibility/modelApiName");
-const _excluded = ["defaultFields"];
-/**
- * Given a model, return an array of tags ensuring the `type` tag is set.
- */
-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");
-  }
-  return tags;
-};
-const createModelsCrud = params => {
-  const {
-    getTenant,
-    getIdentity,
-    getLocale,
-    storageOperations,
-    context
-  } = params;
-  const loaders = {
-    listModels: new _dataloader.default(async () => {
-      const models = await storageOperations.models.list({
-        where: {
-          tenant: getTenant().id,
-          locale: getLocale().code
-        }
-      });
-      return [models.map(model => {
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
-          tags: ensureTypeTag(model),
-          tenant: model.tenant || getTenant().id,
-          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)
-        });
-      })];
-    })
-  };
-  const clearModelsCache = () => {
-    for (const loader of Object.values(loaders)) {
-      loader.clearAll();
-    }
-  };
-  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 checkModelPermissions = check => {
-    return (0, _permissions.checkPermissions)(context, "cms.contentModel", {
-      rwd: check
-    });
-  };
-  const getModelsAsPlugins = () => {
-    const tenant = getTenant().id;
-    const locale = getLocale().code;
-    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: modelTenant,
-        locale: modelLocale
-      } = plugin.contentModel;
-      if (modelTenant && modelTenant !== tenant) {
-        return false;
-      } 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
-      });
-    });
-  };
-  const modelsGet = async modelId => {
-    const pluginModel = getModelsAsPlugins().find(model => model.modelId === modelId);
-    if (pluginModel) {
-      return pluginModel;
-    }
-    const model = await storageOperations.models.get({
-      tenant: getTenant().id,
-      locale: getLocale().code,
-      modelId
-    });
-    if (!model) {
-      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
-    });
-  };
-  const modelsList = async () => {
-    const databaseModels = await loaders.listModels.load("listModels");
-    const pluginsModels = getModelsAsPlugins();
-    return databaseModels.concat(pluginsModels);
-  };
-  const listModels = async () => {
-    return context.benchmark.measure("headlessCms.crud.models.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);
-      });
-    });
-  };
-  const getModel = async modelId => {
-    return context.benchmark.measure("headlessCms.crud.models.getModel", async () => {
-      const permission = await checkModelPermissions("r");
-      const model = await modelsGet(modelId);
-      (0, _ownership.checkOwnership)(context, permission, model);
-      await (0, _access.checkModelAccess)(context, model);
-      return model;
-    });
-  };
-  const getModelManager = async target => {
-    const modelId = typeof target === "string" ? target : target.modelId;
-    if (managers.has(modelId)) {
-      return managers.get(modelId);
-    }
-    const models = await modelsList();
-    const model = models.find(m => m.modelId === modelId);
-    if (!model) {
-      throw new _handlerGraphql.NotFoundError(`There is no content model "${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, _afterCreate.assignModelAfterCreate)({
-    context,
-    onModelAfterCreate
-  });
-  (0, _beforeUpdate.assignModelBeforeUpdate)({
-    onModelBeforeUpdate,
-    context
-  });
-  (0, _afterUpdate.assignModelAfterUpdate)({
-    context,
-    onModelAfterUpdate
-  });
-  (0, _afterCreateFrom.assignModelAfterCreateFrom)({
-    context,
-    onModelAfterCreateFrom
-  });
-  (0, _beforeDelete.assignModelBeforeDelete)({
-    onModelBeforeDelete,
-    plugins: context.plugins,
-    storageOperations
-  });
-  (0, _afterDelete.assignModelAfterDelete)({
-    context,
-    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);
-    }
-    /**
-     * We need to extract the defaultFields because it is not for the CmsModel object.
-     */
-    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: data,
-        model
-      });
-      const createdModel = await storageOperations.models.create({
-        model
-      });
-      loaders.listModels.clearAll();
-      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;
-    }
-  };
-  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
+import error 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";
+import { CmsModelFieldToGraphQLRegistry } from "../features/graphql/index.js";
+const createModelsCrud = (params)=>{
+    const { context } = params;
+    const listFilteredModelsCache = createMemoryCache();
+    const listDatabaseModelsCache = createMemoryCache();
+    const clearModelsCache = ()=>{
+        listDatabaseModelsCache.clear();
+        listFilteredModelsCache.clear();
     };
-    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,
-        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;
-    }
-  };
-  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: data,
-        model,
-        original
-      });
-      const createdModel = await storageOperations.models.create({
-        model
-      });
-      loaders.listModels.clearAll();
-      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;
-    }
-  };
-  const deleteModel = async modelId => {
-    await checkModelPermissions("d");
-    const model = await getModel(modelId);
-    try {
-      await onModelBeforeDelete.publish({
-        model
-      });
-      try {
-        await storageOperations.models.delete({
-          model
+    const fieldTypePlugins = context.container.resolve(CmsModelFieldToGraphQLRegistry).getAll();
+    const getModelToAstConverter = ()=>new CmsModelToAstConverter(new CmsModelFieldToAstConverterFromPlugins(fieldTypePlugins));
+    const listModels = async (input)=>context.benchmark.measure("headlessCms.crud.models.listModels", async ()=>{
+            const useCase = context.container.resolve(ListModelsUseCase);
+            const result = await useCase.execute(input);
+            if (result.isFail()) throw new error(result.error.message, result.error.code, result.error.data);
+            return result.value;
         });
-      } 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
+    const getModel = async (modelId)=>context.benchmark.measure("headlessCms.crud.models.getModel", async ()=>{
+            const useCase = context.container.resolve(GetModelUseCase);
+            const result = await useCase.execute(modelId);
+            if (result.isFail()) throw new error(result.error.message, result.error.code, result.error.data);
+            return result.value;
         });
-      }
-      await onModelAfterDelete.publish({
-        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);
-      });
-    },
-    /**
-     * 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);
-      });
-    },
-    getModelManager,
-    getEntryManager: async model => {
-      return getModelManager(model);
-    },
-    getManagers: () => managers,
-    getEntryManagers: () => managers
-  };
+    const createModel = async (input)=>{
+        const useCase = context.container.resolve(CreateModelUseCase);
+        const result = await useCase.execute(input);
+        if (result.isFail()) throw new error(result.error.message, result.error.code, result.error.data);
+        return result.value;
+    };
+    const updateModel = async (modelId, input)=>{
+        const useCase = context.container.resolve(UpdateModelUseCase);
+        const result = await useCase.execute(modelId, input);
+        if (result.isFail()) throw new error(result.error.message, result.error.code, result.error.data);
+        return result.value;
+    };
+    const createModelFrom = async (modelId, input)=>{
+        const useCase = context.container.resolve(CreateModelFromUseCase);
+        const result = await useCase.execute(modelId, input);
+        if (result.isFail()) throw new error(result.error.message, result.error.code, result.error.data);
+        return result.value;
+    };
+    const deleteModel = async (modelId)=>{
+        const useCase = context.container.resolve(DeleteModelUseCase);
+        const result = await useCase.execute(modelId);
+        if (result.isFail()) throw new error(result.error.message, result.error.code, result.error.data);
+    };
+    return {
+        clearModelsCache,
+        getModel,
+        getModelToAstConverter,
+        listModels,
+        async createModel (input) {
+            return context.benchmark.measure("headlessCms.crud.models.createModel", async ()=>createModel(input));
+        },
+        async createModelFrom (modelId, userInput) {
+            return context.benchmark.measure("headlessCms.crud.models.createModelFrom", async ()=>createModelFrom(modelId, userInput));
+        },
+        async updateModel (modelId, input) {
+            return context.benchmark.measure("headlessCms.crud.models.updateModel", async ()=>updateModel(modelId, input));
+        },
+        async deleteModel (modelId) {
+            return context.benchmark.measure("headlessCms.crud.models.deleteModel", async ()=>deleteModel(modelId));
+        }
+    };
 };
-exports.createModelsCrud = createModelsCrud;
+export { createModelsCrud };
+
+//# sourceMappingURL=contentModel.crud.js.map