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

package/content/plugins/crud/contentModel/afterCreate.d.ts

@@ -0,0 +1,7 @@
+import { AfterModelCreateTopicParams, CmsContext } from "../../../../types";
+import { Topic } from "@webiny/pubsub/types";
+export interface Params {
+    onAfterCreate: Topic<AfterModelCreateTopicParams>;
+    context: CmsContext;
+}
+export declare const assignAfterModelCreate: (params: Params) => void;

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignAfterModelCreate = void 0;
+
+const assignAfterModelCreate = params => {
+  const {
+    onAfterCreate,
+    context
+  } = params;
+  onAfterCreate.subscribe(async () => {
+    await context.cms.updateModelLastChange();
+  });
+};
+
+exports.assignAfterModelCreate = assignAfterModelCreate;

package/content/plugins/crud/contentModel/afterDelete.d.ts

@@ -0,0 +1,7 @@
+import { AfterModelDeleteTopicParams, CmsContext } from "../../../../types";
+import { Topic } from "@webiny/pubsub/types";
+export interface Params {
+    onAfterDelete: Topic<AfterModelDeleteTopicParams>;
+    context: CmsContext;
+}
+export declare const assignAfterModelDelete: (params: Params) => void;

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignAfterModelDelete = void 0;
+
+const assignAfterModelDelete = params => {
+  const {
+    onAfterDelete,
+    context
+  } = params;
+  onAfterDelete.subscribe(async () => {
+    await context.cms.updateModelLastChange();
+  });
+};
+
+exports.assignAfterModelDelete = assignAfterModelDelete;

package/content/plugins/crud/contentModel/afterUpdate.d.ts

@@ -0,0 +1,7 @@
+import { AfterModelUpdateTopicParams, CmsContext } from "../../../../types";
+import { Topic } from "@webiny/pubsub/types";
+export interface Params {
+    onAfterUpdate: Topic<AfterModelUpdateTopicParams>;
+    context: CmsContext;
+}
+export declare const assignAfterModelUpdate: (params: Params) => void;

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignAfterModelUpdate = void 0;
+
+const assignAfterModelUpdate = params => {
+  const {
+    onAfterUpdate,
+    context
+  } = params;
+  onAfterUpdate.subscribe(async () => {
+    await context.cms.updateModelLastChange();
+  });
+};
+
+exports.assignAfterModelUpdate = assignAfterModelUpdate;

package/content/plugins/crud/contentModel/beforeCreate.d.ts

@@ -0,0 +1,9 @@
+import { BeforeModelCreateTopicParams, HeadlessCmsStorageOperations } from "../../../../types";
+import { Topic } from "@webiny/pubsub/types";
+import { PluginsContainer } from "@webiny/plugins";
+export interface Params {
+    onBeforeCreate: Topic<BeforeModelCreateTopicParams>;
+    storageOperations: HeadlessCmsStorageOperations;
+    plugins: PluginsContainer;
+}
+export declare const assignBeforeModelCreate: (params: Params) => void;

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

@@ -0,0 +1,146 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignBeforeModelCreate = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _camelCase = _interopRequireDefault(require("lodash/camelCase"));
+
+var _pluralize = _interopRequireDefault(require("pluralize"));
+
+var _CmsModelPlugin = require("../../CmsModelPlugin");
+
+const disallowedModelIdList = ["contentModel", "contentModels", "contentModelGroup", "contentModelGroups"];
+/**
+ * This list is to disallow creating models that might interfere with GraphQL schema creation.
+ * Add more if required.
+ */
+
+const disallowedModelIdEndingList = ["Response", "List", "Meta", "Input", "Sorter"];
+/**
+ * Checks for the uniqueness of provided modelId, against the provided list of models.
+ * It also takes plural / singular forms of the provided modelId into account.
+ */
+
+const checkModelIdUniqueness = (modelIdList, modelId) => {
+  if (modelIdList.includes(modelId) === true) {
+    throw new _error.default(`Content model with modelId "${modelId}" already exists.`, "MODEL_ID_EXISTS", {
+      modelId
+    });
+  }
+  /**
+   * Additionally, check if the plural form of the received modelId exists too. This prevents users
+   * from creating, for example, "event" and "events" models, which would break the GraphQL schema.
+   * 1. First check if user wants to create the "event" model, but the "events" model already exists.
+   */
+
+
+  const pluralizedModelIdCamelCase = (0, _pluralize.default)(modelId);
+
+  if (modelIdList.includes(pluralizedModelIdCamelCase) === true) {
+    throw new _error.default(`Content model with modelId "${modelId}" does not exist, but a model with modelId "${pluralizedModelIdCamelCase}" does.`, "MODEL_ID_PLURAL_ERROR", {
+      modelId,
+      plural: pluralizedModelIdCamelCase
+    });
+  }
+  /**
+   * 2. Then check if user wants to create the "events" model, but the "event" model already exists.
+   */
+
+
+  const singularizedModelIdCamelCase = _pluralize.default.singular(modelId);
+
+  if (modelIdList.includes(singularizedModelIdCamelCase) === true) {
+    throw new _error.default(`Content model with modelId "${modelId}" does not exist, but a model with modelId "${singularizedModelIdCamelCase}" does.`, "MODEL_ID_SINGULAR_ERROR", {
+      modelId,
+      singular: singularizedModelIdCamelCase
+    });
+  }
+};
+
+const checkModelIdAllowed = modelId => {
+  if (disallowedModelIdList.includes(modelId) === false) {
+    return;
+  }
+
+  throw new _error.default(`Provided model ID "${modelId}" is not allowed.`);
+};
+
+const checkModelIdEndingAllowed = modelId => {
+  for (const ending of disallowedModelIdEndingList) {
+    const re = new RegExp(`${ending}$`, "i");
+    const matched = modelId.match(re);
+
+    if (matched === null) {
+      continue;
+    }
+
+    throw new _error.default(`ModelId that ends with "${ending}" is not allowed.`, "MODEL_ID_NOT_ALLOWED", {
+      modelId
+    });
+  }
+};
+
+const getModelId = model => {
+  const {
+    modelId,
+    name
+  } = model;
+
+  if (modelId) {
+    return (0, _camelCase.default)(modelId.trim());
+  } else if (name) {
+    return (0, _camelCase.default)(name.trim());
+  }
+
+  throw new _error.default(`There is no "modelId" or "name" passed into the create model method.`, "MISSING_MODEL_DATA", {
+    model
+  });
+};
+
+const assignBeforeModelCreate = params => {
+  const {
+    onBeforeCreate,
+    storageOperations,
+    plugins
+  } = params;
+  onBeforeCreate.subscribe(async params => {
+    const {
+      model
+    } = params;
+    const modelId = getModelId(model);
+    const modelPlugin = plugins.byType(_CmsModelPlugin.CmsModelPlugin.type).find(item => item.contentModel.modelId === modelId);
+
+    if (modelPlugin) {
+      throw new _error.default(`Cannot create "${model.modelId}" content model because one is already registered via a plugin.`, "CONTENT_MODEL_CREATE_ERROR", {
+        modelId: model.modelId
+      });
+    }
+
+    const models = await storageOperations.models.list({
+      where: {
+        tenant: model.tenant,
+        locale: model.locale
+      }
+    });
+    const modelIdList = models.map(m => m.modelId);
+    /**
+     * We need to check for:
+     *  - is that exact modelId allowed
+     *  - is modelId unique
+     *  - is model ending allowed
+     */
+
+    checkModelIdAllowed(modelId);
+    checkModelIdEndingAllowed(modelId);
+    checkModelIdUniqueness(modelIdList, modelId);
+    model.modelId = modelId;
+  });
+};
+
+exports.assignBeforeModelCreate = assignBeforeModelCreate;

package/content/plugins/crud/contentModel/beforeDelete.d.ts

@@ -0,0 +1,9 @@
+import { Topic } from "@webiny/pubsub/types";
+import { BeforeModelDeleteTopicParams, HeadlessCmsStorageOperations } from "../../../../types";
+import { PluginsContainer } from "@webiny/plugins";
+export interface Params {
+    onBeforeDelete: Topic<BeforeModelDeleteTopicParams>;
+    storageOperations: HeadlessCmsStorageOperations;
+    plugins: PluginsContainer;
+}
+export declare const assignBeforeModelDelete: (params: Params) => void;

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

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignBeforeModelDelete = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _CmsModelPlugin = require("../../CmsModelPlugin");
+
+const assignBeforeModelDelete = params => {
+  const {
+    onBeforeDelete,
+    storageOperations,
+    plugins
+  } = params;
+  onBeforeDelete.subscribe(async params => {
+    const {
+      model
+    } = params;
+    const modelPlugin = plugins.byType(_CmsModelPlugin.CmsModelPlugin.type).find(item => item.contentModel.modelId === model.modelId);
+
+    if (modelPlugin) {
+      throw new _error.default("Content models defined via plugins cannot be deleted.", "CONTENT_MODEL_DELETE_ERROR", {
+        modelId: model.modelId
+      });
+    }
+
+    let entries = [];
+
+    try {
+      const result = await storageOperations.entries.list(model, {
+        where: {
+          tenant: model.tenant,
+          locale: model.locale
+        },
+        limit: 1
+      });
+      entries = result.items;
+    } catch (ex) {
+      throw new _error.default("Could not retrieve a list of content entries from the model.", "ENTRIES_ERROR", {
+        error: ex,
+        model
+      });
+    }
+
+    if (entries.length > 0) {
+      throw new _error.default(`Cannot delete content model "${model.modelId}" because there are existing entries.`, "CONTENT_MODEL_BEFORE_DELETE_HOOK_FAILED");
+    }
+  });
+};
+
+exports.assignBeforeModelDelete = assignBeforeModelDelete;

package/content/plugins/crud/contentModel/beforeUpdate.d.ts

@@ -0,0 +1,9 @@
+import { Topic } from "@webiny/pubsub/types";
+import { BeforeModelUpdateTopicParams, HeadlessCmsStorageOperations } from "../../../../types";
+import { PluginsContainer } from "@webiny/plugins";
+export interface Params {
+    onBeforeUpdate: Topic<BeforeModelUpdateTopicParams>;
+    storageOperations: HeadlessCmsStorageOperations;
+    plugins: PluginsContainer;
+}
+export declare const assignBeforeModelUpdate: (params: Params) => void;

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

@@ -0,0 +1,128 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignBeforeModelUpdate = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _CmsModelPlugin = require("../../CmsModelPlugin");
+
+const defaultTitleFieldId = "id";
+const allowedTitleFieldTypes = ["text", "number"];
+
+const getContentModelTitleFieldId = (fields, titleFieldId) => {
+  // if there is no title field defined either in input data or existing content model data
+  // we will take first text field that has no multiple values enabled
+  // or if initial titleFieldId is the default one also try to find first available text field
+  if (!titleFieldId || titleFieldId === defaultTitleFieldId) {
+    const titleField = fields.find(field => {
+      return field.type === "text" && !field.multipleValues;
+    });
+    return titleField ? titleField.fieldId : defaultTitleFieldId;
+  } // check existing titleFieldId for existence in the model
+  // for correct type
+  // and that it is not multiple values field
+
+
+  const target = fields.find(f => f.fieldId === titleFieldId);
+
+  if (!target) {
+    throw new _error.default(`Field does not exist in the model.`, "VALIDATION_ERROR", {
+      fieldId: titleFieldId
+    });
+  }
+
+  if (allowedTitleFieldTypes.includes(target.type) === false) {
+    throw new _error.default(`Only ${allowedTitleFieldTypes.join(", ")} and id fields can be used as an entry title.`, "ENTRY_TITLE_FIELD_TYPE", {
+      fieldId: target.fieldId,
+      type: target.type
+    });
+  }
+
+  if (target.multipleValues) {
+    throw new _error.default(`Fields that accept multiple values cannot be used as the entry title.`, "ENTRY_TITLE_FIELD_TYPE", {
+      fieldId: target.fieldId,
+      type: target.type
+    });
+  }
+
+  return target.fieldId;
+};
+
+const assignBeforeModelUpdate = params => {
+  const {
+    onBeforeUpdate,
+    plugins
+  } = params;
+  onBeforeUpdate.subscribe(async params => {
+    const {
+      model
+    } = params;
+    const modelPlugin = plugins.byType(_CmsModelPlugin.CmsModelPlugin.type).find(item => item.contentModel.modelId === model.modelId);
+
+    if (modelPlugin) {
+      throw new _error.default("Content models defined via plugins cannot be updated.", "CONTENT_MODEL_UPDATE_ERROR", {
+        modelId: model.modelId
+      });
+    }
+
+    const {
+      titleFieldId
+    } = model; // There should be fields/locked fields in either model or data to be updated.
+
+    const {
+      fields = [],
+      lockedFields = []
+    } = model; // Let's inspect the fields of the received content model. We prevent saving of a content model if it
+    // contains a field for which a "cms-model-field-to-graphql" plugin does not exist on the backend.
+
+    const fieldTypePlugins = plugins.byType("cms-model-field-to-graphql");
+
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i];
+
+      if (!fieldTypePlugins.find(item => item.fieldType === field.type)) {
+        throw new Error(`Cannot update content model because of the unknown "${field.type}" field.`);
+      }
+    }
+
+    model.titleFieldId = getContentModelTitleFieldId(fields, titleFieldId);
+    const cmsLockedFieldPlugins = plugins.byType("cms-model-locked-field"); // We must not allow removal or changes in fields that are already in use in content entries.
+
+    for (const lockedField of lockedFields) {
+      const existingField = fields.find(item => item.fieldId === lockedField.fieldId);
+
+      if (!existingField) {
+        throw new _error.default(`Cannot remove the field "${lockedField.fieldId}" because it's already in use in created content.`, "ENTRY_FIELD_USED");
+      }
+
+      if (lockedField.multipleValues !== existingField.multipleValues) {
+        throw new _error.default(`Cannot change "multipleValues" for the "${lockedField.fieldId}" field because it's already in use in created content.`, "ENTRY_FIELD_USED");
+      }
+
+      if (lockedField.type !== existingField.type) {
+        throw new _error.default(`Cannot change field type for the "${lockedField.fieldId}" field because it's already in use in created content.`, "ENTRY_FIELD_USED");
+      } // Check `lockedField` invariant for specific field
+
+
+      const lockedFieldsByType = cmsLockedFieldPlugins.filter(pl => pl.fieldType === lockedField.type);
+
+      for (const plugin of lockedFieldsByType) {
+        if (typeof plugin.checkLockedField !== "function") {
+          continue;
+        }
+
+        plugin.checkLockedField({
+          lockedField,
+          field: existingField
+        });
+      }
+    }
+  });
+};
+
+exports.assignBeforeModelUpdate = assignBeforeModelUpdate;

package/content/plugins/crud/contentModel/contentModelManagerFactory.d.ts

@@ -1,2 +1,2 @@
-import { CmsContentModel, CmsContext } from "../../../../types";
-export declare const contentModelManagerFactory: (context: CmsContext, model: CmsContentModel) => Promise<import("../../../../types").CmsContentModelManager>;
+import { CmsModel, CmsContext } from "../../../../types";
+export declare const contentModelManagerFactory: (context: CmsContext, model: CmsModel) => Promise<import("../../../../types").CmsModelManager>;

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

@@ -20,11 +20,10 @@ const contentModelManagerFactory = async (context, model) => {
   const plugin = pluginsByType.find(plugin => plugin.name === defaultName);
 
   if (!plugin) {
-    throw new Error("There is no default plugin to create ContentModelManager");
+    throw new Error("There is no default plugin to create CmsModelManager");
   }
 
   return await plugin.create(context, model);
 };
 
-exports.contentModelManagerFactory = contentModelManagerFactory;
-//# sourceMappingURL=contentModelManagerFactory.js.map
+exports.contentModelManagerFactory = contentModelManagerFactory;

package/content/plugins/crud/contentModel/createFieldModels.d.ts

@@ -1,2 +1,2 @@
-import { CmsContentModelField, CmsContentModel, CmsContentModelUpdateInput } from "../../../../types";
-export declare const createFieldModels: (model: CmsContentModel, data: CmsContentModelUpdateInput) => Promise<CmsContentModelField[]>;
+import { CmsModelField, CmsModel, CmsModelUpdateInput } from "../../../../types";
+export declare const createFieldModels: (_: CmsModel, data: CmsModelUpdateInput) => Promise<CmsModelField[]>;

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

@@ -7,7 +7,7 @@ exports.createFieldModels = void 0;
 
 var _models = require("./models");
 
-const createFieldModels = async (model, data) => {
+const createFieldModels = async (_, data) => {
   const fields = [];
 
   for (const field of data.fields) {
@@ -19,5 +19,4 @@ const createFieldModels = async (model, data) => {
   return fields;
 };
 
-exports.createFieldModels = createFieldModels;
-//# sourceMappingURL=createFieldModels.js.map
+exports.createFieldModels = createFieldModels;

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

@@ -19,5 +19,4 @@ var _default = async value => {
   }
 };
 
-exports.default = _default;
-//# sourceMappingURL=idValidation.js.map
+exports.default = _default;

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

@@ -138,5 +138,4 @@ const UpdateContentModelModel = (0, _fields.withFields)({
     required: true
   })
 })();
-exports.UpdateContentModelModel = UpdateContentModelModel;
-//# sourceMappingURL=models.js.map
+exports.UpdateContentModelModel = UpdateContentModelModel;

package/content/plugins/crud/contentModel/validateLayout.d.ts

@@ -1,2 +1,2 @@
-import { CmsContentModelField, CmsContentModel } from "../../../../types";
-export declare const validateLayout: ({ layout }: CmsContentModel, fields: CmsContentModelField[]) => void;
+import { CmsModelField, CmsModel } from "../../../../types";
+export declare const validateLayout: ({ layout }: CmsModel, fields: CmsModelField[]) => void;

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

@@ -35,5 +35,4 @@ const validateLayout = ({
   }
 };
 
-exports.validateLayout = validateLayout;
-//# sourceMappingURL=validateLayout.js.map
+exports.validateLayout = validateLayout;

package/content/plugins/crud/contentModel.crud.d.ts

@@ -1,4 +1,12 @@
-import { ContextPlugin } from "@webiny/handler/types";
-import { CmsContext } from "../../../types";
-declare const _default: () => ContextPlugin<CmsContext>;
-export default _default;
+import { CmsContext, CmsModelContext, HeadlessCmsStorageOperations } from "../../../types";
+import { Tenant } from "@webiny/api-tenancy/types";
+import { I18NLocale } from "@webiny/api-i18n/types";
+import { SecurityIdentity } from "@webiny/api-security/types";
+export interface Params {
+    getTenant: () => Tenant;
+    getLocale: () => I18NLocale;
+    storageOperations: HeadlessCmsStorageOperations;
+    context: CmsContext;
+    getIdentity: () => SecurityIdentity;
+}
+export declare const createModelsCrud: (params: Params) => CmsModelContext;