@webiny/api-headless-cms 0.0.0-mt-1

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.contentModelManagerFactory = void 0;
+const defaultName = "content-model-manager-default";
+
+const contentModelManagerFactory = async (context, model) => {
+  const pluginsByType = context.plugins.byType("cms-content-model-manager").reverse();
+
+  for (const plugin of pluginsByType) {
+    const target = Array.isArray(plugin.modelId) ? plugin.modelId : [plugin.modelId];
+
+    if (target.includes(model.modelId) === true && plugin.name !== defaultName) {
+      return await plugin.create(context, model);
+    }
+  }
+
+  const plugin = pluginsByType.find(plugin => plugin.name === defaultName);
+
+  if (!plugin) {
+    throw new Error("There is no default plugin to create CmsModelManager");
+  }
+
+  return await plugin.create(context, model);
+};
+
+exports.contentModelManagerFactory = contentModelManagerFactory;

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFieldModels = void 0;
+
+var _models = require("./models");
+
+const createFieldModels = async (_, data) => {
+  const fields = [];
+
+  for (const field of data.fields) {
+    const fieldData = new _models.ContentModelFieldModel().populate(field);
+    await fieldData.validate();
+    fields.push(await fieldData.toJSON());
+  }
+
+  return fields;
+};
+
+exports.createFieldModels = createFieldModels;

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

@@ -0,0 +1,2 @@
+declare const _default: (value: string) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validation = require("@webiny/validation");
+
+var _default = async value => {
+  await _validation.validation.validate(value, "required,maxLength:100");
+
+  if (!value.charAt(0).match(/[a-zA-Z]/)) {
+    throw new Error(`Provided ID ${value} is not valid - must not start with a number.`);
+  }
+
+  if (value.trim().toLowerCase() === "id") {
+    throw new Error(`Provided ID ${value} is not valid - "id" is an auto-generated field.`);
+  }
+};
+
+exports.default = _default;

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

@@ -0,0 +1,3 @@
+export declare const CreateContentModelModel: any;
+export declare const ContentModelFieldModel: any;
+export declare const UpdateContentModelModel: any;

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

@@ -0,0 +1,141 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UpdateContentModelModel = exports.CreateContentModelModel = exports.ContentModelFieldModel = void 0;
+
+var _validation = require("@webiny/validation");
+
+var _flow = _interopRequireDefault(require("lodash/flow"));
+
+var _commodoFieldsObject = require("commodo-fields-object");
+
+var _fields = require("@commodo/fields");
+
+var _idValidation = _interopRequireDefault(require("./idValidation"));
+
+const requiredShortString = _validation.validation.create("required,maxLength:255");
+
+const shortString = _validation.validation.create("maxLength:255");
+
+const CreateContentModelModel = (0, _fields.withFields)({
+  name: (0, _fields.string)({
+    validation: requiredShortString
+  }),
+  modelId: (0, _fields.string)({
+    validation: shortString
+  }),
+  description: (0, _fields.string)({
+    validation: shortString
+  }),
+  group: (0, _fields.string)({
+    validation: requiredShortString
+  })
+})();
+exports.CreateContentModelModel = CreateContentModelModel;
+const RendererModel = (0, _fields.withFields)({
+  name: (0, _fields.string)({
+    validation: requiredShortString
+  })
+})();
+const ContentModelFieldModel = (0, _fields.withFields)({
+  id: (0, _fields.string)({
+    validation: requiredShortString
+  }),
+  fieldId: (0, _flow.default)((0, _fields.onSet)(value => value && value.trim()), (0, _fields.setOnce)())((0, _fields.string)({
+    validation: _idValidation.default
+  })),
+  label: (0, _fields.string)({
+    validation: requiredShortString
+  }),
+  helpText: (0, _fields.string)({
+    validation: shortString
+  }),
+  placeholderText: (0, _fields.string)({
+    validation: shortString
+  }),
+  type: (0, _fields.setOnce)()((0, _fields.string)({
+    validation: requiredShortString
+  })),
+  multipleValues: (0, _fields.boolean)({
+    value: false
+  }),
+  predefinedValues: (0, _fields.fields)({
+    value: {},
+    instanceOf: (0, _fields.withFields)({
+      enabled: (0, _fields.boolean)(),
+      values: (0, _fields.fields)({
+        value: [],
+        list: true,
+        instanceOf: (0, _fields.withFields)({
+          label: (0, _fields.string)(),
+          value: (0, _fields.string)()
+        })()
+      })
+    })()
+  }),
+  renderer: (0, _fields.fields)({
+    instanceOf: RendererModel,
+    validation: shortString
+  }),
+  validation: (0, _fields.fields)({
+    list: true,
+    value: [],
+    instanceOf: (0, _fields.withFields)({
+      name: (0, _fields.string)({
+        validation: requiredShortString
+      }),
+      message: (0, _fields.string)({
+        validation: shortString
+      }),
+      settings: (0, _commodoFieldsObject.object)({
+        value: {}
+      })
+    })()
+  }),
+  listValidation: (0, _fields.fields)({
+    list: true,
+    value: [],
+    instanceOf: (0, _fields.withFields)({
+      name: (0, _fields.string)({
+        validation: requiredShortString
+      }),
+      message: (0, _fields.string)({
+        validation: shortString
+      }),
+      settings: (0, _commodoFieldsObject.object)({
+        value: {}
+      })
+    })()
+  }),
+  settings: (0, _commodoFieldsObject.object)({
+    value: {}
+  })
+})();
+exports.ContentModelFieldModel = ContentModelFieldModel;
+const UpdateContentModelModel = (0, _fields.withFields)({
+  name: (0, _fields.string)({
+    validation: shortString
+  }),
+  description: (0, _fields.string)({
+    validation: shortString
+  }),
+  group: (0, _fields.string)({
+    validation: shortString
+  }),
+  titleFieldId: (0, _fields.string)(),
+  fields: (0, _fields.fields)({
+    instanceOf: ContentModelFieldModel,
+    value: [],
+    list: true,
+    required: true
+  }),
+  layout: (0, _commodoFieldsObject.object)({
+    value: [],
+    required: true
+  })
+})();
+exports.UpdateContentModelModel = UpdateContentModelModel;

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

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