@webiny/api-headless-cms 5.17.4 → 5.18.0-beta.3

package/content/plugins/crud/contentModel.crud.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.createModelsCrud = void 0;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
@@ -23,13 +23,25 @@ var _createFieldModels = require("./contentModel/createFieldModels");
 
 var _validateLayout = require("./contentModel/validateLayout");
 
-var _hooks = require("./contentModel/hooks");
-
 var _apiSecurity = require("@webiny/api-security");
 
 var _error = _interopRequireDefault(require("@webiny/error"));
 
-var _ContentModelPlugin = require("@webiny/api-headless-cms/content/plugins/ContentModelPlugin");
+var _CmsModelPlugin = require("../CmsModelPlugin");
+
+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");
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
@@ -39,315 +51,375 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-var _default = () => ({
-  type: "context",
-  name: "context-content-model-storageOperations",
+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 _objectSpread(_objectSpread({}, model), {}, {
+          tenant: model.tenant || getTenant().id,
+          locale: model.locale || getLocale().code
+        });
+      })];
+    })
+  };
+  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 utils.checkPermissions(context, "cms.contentModel", {
+      rwd: check
+    });
+  };
 
-  async apply(context) {
+  const getModelsAsPlugins = () => {
+    const tenant = getTenant().id;
+    const locale = getLocale().code;
+    return context.plugins.byType(_CmsModelPlugin.CmsModelPlugin.type)
     /**
-     * If cms is not defined on the context, do not continue, but log it.
+     * 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
      */
-    if (!context.cms) {
-      return;
-    }
+    .filter(plugin => {
+      const {
+        tenant: t,
+        locale: l
+      } = plugin.contentModel;
+
+      if (t && t !== tenant) {
+        return false;
+      } else if (l && l !== locale) {
+        return false;
+      }
 
-    const pluginType = "cms-content-model-storage-operations-provider";
-    const providerPlugins = context.plugins.byType(pluginType);
-    /**
-     * Storage operations for the content model.
-     * Contains logic to save the data into the specific storage.
-     */
+      return true;
+    }).map(plugin => {
+      return _objectSpread(_objectSpread({}, plugin.contentModel), {}, {
+        tenant,
+        locale,
+        webinyVersion: context.WEBINY_VERSION
+      });
+    });
+  };
 
-    const providerPlugin = providerPlugins[providerPlugins.length - 1];
+  const modelsGet = async modelId => {
+    const pluginModel = getModelsAsPlugins().find(model => model.modelId === modelId);
 
-    if (!providerPlugin) {
-      throw new _error.default(`Missing "${pluginType}" plugin.`, "PLUGIN_NOT_FOUND", {
-        type: pluginType
-      });
+    if (pluginModel) {
+      return pluginModel;
     }
 
-    const storageOperations = await providerPlugin.provide({
-      context
+    const model = await storageOperations.models.get({
+      tenant: getTenant().id,
+      locale: getLocale().code,
+      modelId
     });
-    const loaders = {
-      listModels: new _dataloader.default(async () => {
-        const models = await storageOperations.list();
-        return [models];
-      })
-    };
-    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 utils.checkPermissions(context, "cms.contentModel", {
-        rwd: check
-      });
-    };
 
-    const modelsGet = async modelId => {
-      const pluginModel = context.plugins.byType(_ContentModelPlugin.ContentModelPlugin.type).find(plugin => plugin.contentModel.modelId === modelId);
+    if (!model) {
+      throw new _handlerGraphql.NotFoundError(`Content model "${modelId}" was not found!`);
+    }
 
-      if (pluginModel) {
-        return pluginModel.contentModel;
+    return _objectSpread(_objectSpread({}, 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 listOperations = async () => {
+    const permission = await checkModelPermissions("r");
+    const models = await modelsList();
+    return utils.filterAsync(models, async model => {
+      if (!utils.validateOwnership(context, permission, model)) {
+        return false;
       }
 
-      const databaseModel = await storageOperations.get({
-        id: modelId
-      });
-
-      if (!databaseModel) {
-        throw new _handlerGraphql.NotFoundError(`Content model "${modelId}" was not found!`);
-      }
+      return utils.validateModelAccess(context, model);
+    });
+  };
+
+  const get = async modelId => {
+    const permission = await checkModelPermissions("r");
+    const model = await modelsGet(modelId);
+    utils.checkOwnership(context, permission, model);
+    await utils.checkModelAccess(context, model);
+    return model;
+  };
+
+  const getManager = async modelId => {
+    if (managers.has(modelId)) {
+      return managers.get(modelId);
+    }
 
-      return databaseModel;
-    };
-
-    const modelsList = async () => {
-      const databaseModels = await loaders.listModels.load("listModels");
-      const pluginsModels = context.plugins.byType(_ContentModelPlugin.ContentModelPlugin.type).map(plugin => plugin.contentModel);
-      return [...databaseModels, ...pluginsModels];
-    };
-
-    const models = {
-      operations: storageOperations,
-      noAuth: () => {
-        return {
-          get: modelsGet,
-          list: modelsList
-        };
-      },
-      silentAuth: () => {
-        return {
-          list: async () => {
-            try {
-              return await models.list();
-            } catch (ex) {
-              if (ex instanceof _apiSecurity.NotAuthorizedError) {
-                return [];
-              }
-
-              throw ex;
-            }
-          }
-        };
-      },
-
-      async get(modelId) {
-        const permission = await checkModelPermissions("r");
-        const model = await modelsGet(modelId);
-        utils.checkOwnership(context, permission, model);
-        await utils.checkModelAccess(context, model);
-        return model;
-      },
-
-      async list() {
-        const permission = await checkModelPermissions("r");
-        const models = await modelsList();
-        return utils.filterAsync(models, async model => {
-          if (!utils.validateOwnership(context, permission, model)) {
-            return false;
-          }
+    const models = await modelsList();
+    const model = models.find(m => m.modelId === modelId);
 
-          return utils.validateModelAccess(context, model);
-        });
-      },
+    if (!model) {
+      throw new _handlerGraphql.NotFoundError(`There is no content model "${modelId}".`);
+    }
 
-      async create(inputData) {
-        await checkModelPermissions("w");
-        const createdData = new _models.CreateContentModelModel().populate(inputData);
-        await createdData.validate();
-        const input = await createdData.toJSON();
-        const group = await context.cms.groups.noAuth().get(input.group);
+    return await updateManager(context, model);
+  };
+
+  const onBeforeCreate = (0, _pubsub.createTopic)();
+  const onAfterCreate = (0, _pubsub.createTopic)();
+  const onBeforeUpdate = (0, _pubsub.createTopic)();
+  const onAfterUpdate = (0, _pubsub.createTopic)();
+  const onBeforeDelete = (0, _pubsub.createTopic)();
+  const onAfterDelete = (0, _pubsub.createTopic)();
+  /**
+   * We need to assign some default behaviors.
+   */
+
+  (0, _beforeCreate.assignBeforeModelCreate)({
+    onBeforeCreate,
+    plugins: context.plugins,
+    storageOperations
+  });
+  (0, _afterCreate.assignAfterModelCreate)({
+    context,
+    onAfterCreate
+  });
+  (0, _beforeUpdate.assignBeforeModelUpdate)({
+    onBeforeUpdate,
+    plugins: context.plugins,
+    storageOperations
+  });
+  (0, _afterUpdate.assignAfterModelUpdate)({
+    context,
+    onAfterUpdate
+  });
+  (0, _beforeDelete.assignBeforeModelDelete)({
+    onBeforeDelete,
+    plugins: context.plugins,
+    storageOperations
+  });
+  (0, _afterDelete.assignAfterModelDelete)({
+    context,
+    onAfterDelete
+  });
+  return {
+    onBeforeModelCreate: onBeforeCreate,
+    onAfterModelCreate: onAfterCreate,
+    onBeforeModelUpdate: onBeforeUpdate,
+    onAfterModelUpdate: onAfterUpdate,
+    onBeforeModelDelete: onBeforeDelete,
+    onAfterModelDelete: onAfterDelete,
+    silentAuthModel: () => {
+      return {
+        list: async () => {
+          try {
+            return await listOperations();
+          } catch (ex) {
+            if (ex instanceof _apiSecurity.NotAuthorizedError) {
+              return [];
+            }
 
-        if (!group) {
-          throw new _handlerGraphql.NotFoundError(`There is no group "${input.group}".`);
+            throw ex;
+          }
         }
+      };
+    },
+    getModel: get,
+    listModels: listOperations,
+
+    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 identity = context.security.getIdentity();
-
-        const data = _objectSpread(_objectSpread({}, input), {}, {
-          titleFieldId: "id",
-          locale: context.cms.getLocale().code,
-          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: []
-        });
+      const identity = getIdentity();
+
+      const model = _objectSpread(_objectSpread({}, input), {}, {
+        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: [],
+        webinyVersion: context.WEBINY_VERSION
+      });
 
-        await (0, _hooks.beforeCreateHook)({
-          context,
-          storageOperations,
-          input,
-          data
-        });
-        const model = await storageOperations.create({
-          input,
-          data
-        });
-        await updateManager(context, model);
-        await (0, _hooks.afterCreateHook)({
-          context,
-          storageOperations,
-          input,
-          model
-        });
-        return model;
-      },
-
-      /**
-       * Method does not check for permissions or ownership.
-       * @internal
-       */
-      async updateModel(model, data) {
-        const input = data;
-        await (0, _hooks.beforeUpdateHook)({
-          context,
-          storageOperations,
-          model,
-          data,
-          input
-        });
-        const resultModel = await storageOperations.update({
-          data,
-          model,
-          input
-        });
-        await updateManager(context, resultModel);
-        await (0, _hooks.afterUpdateHook)({
-          context,
-          storageOperations,
-          model: resultModel,
-          data,
-          input
-        });
-        return resultModel;
-      },
+      await onBeforeCreate.publish({
+        model,
+        input
+      });
+      const createdModel = await storageOperations.models.create({
+        input,
+        model
+      });
+      loaders.listModels.clearAll();
+      await updateManager(context, model);
+      await onAfterCreate.publish({
+        input,
+        model: createdModel
+      });
+      return createdModel;
+    },
 
-      async update(modelId, inputData) {
-        await checkModelPermissions("w"); // Get a model record; this will also perform ownership validation.
+    /**
+     * Method does not check for permissions or ownership.
+     * @internal
+     */
+    async updateModelDirect(params) {
+      const {
+        model: initialModel,
+        original
+      } = params;
+
+      const model = _objectSpread(_objectSpread({}, initialModel), {}, {
+        tenant: initialModel.tenant || getTenant().id,
+        locale: initialModel.locale || getLocale().code,
+        webinyVersion: context.WEBINY_VERSION
+      });
 
-        const model = await context.cms.models.get(modelId);
-        const updatedData = new _models.UpdateContentModelModel().populate(inputData);
-        await updatedData.validate();
-        const input = await updatedData.toJSON({
-          onlyDirty: true
-        });
+      await onBeforeUpdate.publish({
+        input: {},
+        original,
+        model
+      });
+      const resultModel = await storageOperations.models.update({
+        original,
+        model,
+        input: {}
+      });
+      await updateManager(context, resultModel);
+      loaders.listModels.clearAll();
+      await onAfterUpdate.publish({
+        input: {},
+        original,
+        model: resultModel
+      });
+      return resultModel;
+    },
 
-        if (Object.keys(input).length === 0) {
-          return {};
-        }
+    async updateModel(modelId, inputData) {
+      await checkModelPermissions("w"); // Get a model record; this will also perform ownership validation.
 
-        if (input.group) {
-          const group = await context.cms.groups.noAuth().get(input.group);
+      const original = await get(modelId);
+      const updatedData = new _models.UpdateContentModelModel().populate(inputData);
+      await updatedData.validate();
+      const input = await updatedData.toJSON({
+        onlyDirty: true
+      });
 
-          if (!group) {
-            throw new _handlerGraphql.NotFoundError(`There is no group "${input.group}".`);
-          }
+      if (Object.keys(input).length === 0) {
+        return {};
+      }
 
-          input.group = {
-            id: group.id,
-            name: group.name
-          };
+      if (input.group) {
+        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 modelFields = await (0, _createFieldModels.createFieldModels)(model, inputData);
-        (0, _validateLayout.validateLayout)(input, modelFields);
+        input.group = {
+          id: group.id,
+          name: group.name
+        };
+      }
 
-        const data = _objectSpread(_objectSpread({}, input), {}, {
-          fields: modelFields,
-          savedOn: new Date().toISOString()
-        });
+      const modelFields = await (0, _createFieldModels.createFieldModels)(original, inputData);
+      (0, _validateLayout.validateLayout)(input, modelFields);
 
-        await (0, _hooks.beforeUpdateHook)({
-          context,
-          storageOperations,
-          model,
-          data,
-          input
-        });
-        const resultModel = await storageOperations.update({
-          data,
-          model,
-          input
-        });
-        await updateManager(context, resultModel);
-        await (0, _hooks.afterUpdateHook)({
-          context,
-          storageOperations,
-          model: resultModel,
-          data,
-          input
-        });
-        return resultModel;
-      },
-
-      async delete(modelId) {
-        await checkModelPermissions("d");
-        const model = await context.cms.models.get(modelId);
-        await (0, _hooks.beforeDeleteHook)({
-          context,
-          storageOperations,
-          model
-        });
-        const result = await storageOperations.delete({
-          model
-        });
+      const model = _objectSpread(_objectSpread(_objectSpread({}, original), input), {}, {
+        tenant: original.tenant || getTenant().id,
+        locale: original.locale || getLocale().code,
+        webinyVersion: context.WEBINY_VERSION,
+        fields: modelFields,
+        savedOn: new Date().toISOString()
+      });
 
-        if (!result) {
-          throw new _error.default("Could not delete the content model", "CONTENT_MODEL_DELETE_ERROR", {
-            modelId: model.modelId
-          });
-        }
+      await onBeforeUpdate.publish({
+        input,
+        original,
+        model
+      });
+      const resultModel = await storageOperations.models.update({
+        original,
+        model,
+        input
+      });
+      await updateManager(context, resultModel);
+      await onAfterUpdate.publish({
+        original,
+        model: resultModel,
+        input
+      });
+      return resultModel;
+    },
+
+    async deleteModel(modelId) {
+      await checkModelPermissions("d");
+      const model = await get(modelId);
+      await onBeforeDelete.publish({
+        model
+      });
 
-        await (0, _hooks.afterDeleteHook)({
-          context,
-          storageOperations,
+      try {
+        await storageOperations.models.delete({
           model
         });
-        managers.delete(model.modelId);
-      },
-
-      async getManager(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);
-      },
-
-      getManagers: () => managers
-    };
-    context.cms = _objectSpread(_objectSpread({}, context.cms || {}), {}, {
-      models,
-      getModel: modelId => {
-        return models.getManager(modelId);
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not delete the content model", ex.code || "CONTENT_MODEL_DELETE_ERROR", {
+          error: ex,
+          modelId: model.modelId
+        });
       }
-    });
-  }
 
-});
+      await onAfterDelete.publish({
+        model
+      });
+      managers.delete(model.modelId);
+    },
+
+    getModelManager: getManager,
+    getManagers: () => managers
+  };
+};
 
-exports.default = _default;
-//# sourceMappingURL=contentModel.crud.js.map
+exports.createModelsCrud = createModelsCrud;