@webiny/api-headless-cms 0.0.0-ee-vpcs.549378cf03

package/crud/contentModel.crud.js

@@ -0,0 +1,650 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModelsCrud = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _dataloader = _interopRequireDefault(require("dataloader"));
+
+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");
+
+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 _validateModelFields = require("./contentModel/validateModelFields");
+
+/**
+ * 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
+        });
+      })];
+    })
+  };
+
+  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;
+    const models = 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
+      });
+    });
+    /**
+     * 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);
+
+    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 () => {
+    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 => {
+    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,
+    plugins: context.plugins,
+    storageOperations
+  });
+  (0, _afterCreate.assignModelAfterCreate)({
+    context,
+    onModelAfterCreate
+  });
+  (0, _beforeUpdate.assignModelBeforeUpdate)({
+    onModelBeforeUpdate,
+    plugins: context.plugins,
+    storageOperations
+  });
+  (0, _afterUpdate.assignModelAfterUpdate)({
+    context,
+    onModelAfterUpdate
+  });
+  (0, _afterCreateFrom.assignModelAfterCreateFrom)({
+    context,
+    onModelAfterCreateFrom
+  });
+  (0, _beforeDelete.assignModelBeforeDelete)({
+    onModelBeforeDelete,
+    plugins: context.plugins,
+    storageOperations
+  });
+  (0, _afterDelete.assignModelAfterDelete)({
+    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,
+
+    /**
+     * Released in 5.34.0
+     */
+    onModelBeforeCreate,
+    onModelAfterCreate,
+    onModelCreateError,
+    onModelBeforeCreateFrom,
+    onModelAfterCreateFrom,
+    onModelCreateFromError,
+    onModelBeforeUpdate,
+    onModelAfterUpdate,
+    onModelUpdateError,
+    onModelBeforeDelete,
+    onModelAfterDelete,
+    onModelDeleteError,
+    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 || [],
+        tags: [...(input.tags || [])],
+        webinyVersion: context.WEBINY_VERSION
+      };
+      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;
+      }
+    },
+
+    /**
+     * 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
+      });
+
+      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) {
+      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
+      });
+
+      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) {
+      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()
+      });
+      model.tags = ensureTypeTag(model);
+
+      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);
+
+      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
+          });
+        }
+
+        await onModelAfterDelete.publish({
+          model
+        });
+        managers.delete(model.modelId);
+      } catch (ex) {
+        await onModelDeleteError.publish({
+          model,
+          error: ex
+        });
+        throw ex;
+      }
+    },
+
+    async initializeModel(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;
+    },
+
+    getModelManager,
+    getEntryManager: async model => {
+      return getModelManager(model);
+    },
+    getManagers: () => managers,
+    getEntryManagers: () => managers
+  };
+};
+
+exports.createModelsCrud = createModelsCrud;