@akemona-org/strapi-plugin-content-type-builder 3.7.0

package/controllers/ContentTypes.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const _ = require('lodash');
+
+// const { hasDraftAndPublish } = require('@akemona-org/strapi-utils').contentTypes;
+
+const {
+  validateContentTypeInput,
+  validateUpdateContentTypeInput,
+  validateKind,
+} = require('./validation/content-type');
+
+module.exports = {
+  async getContentTypes(ctx) {
+    const { kind } = ctx.query;
+
+    try {
+      await validateKind(kind);
+    } catch (error) {
+      return ctx.send({ error }, 400);
+    }
+
+    const contentTypeService = strapi.plugins['content-type-builder'].services.contenttypes;
+
+    const contentTypes = Object.keys(strapi.contentTypes)
+      .filter((uid) => !kind || _.get(strapi.contentTypes[uid], 'kind', 'collectionType') === kind)
+      .map((uid) => contentTypeService.formatContentType(strapi.contentTypes[uid]));
+
+    ctx.send({
+      data: contentTypes,
+    });
+  },
+
+  getContentType(ctx) {
+    const { uid } = ctx.params;
+
+    const contentType = strapi.contentTypes[uid];
+
+    if (!contentType) {
+      return ctx.send({ error: 'contentType.notFound' }, 404);
+    }
+
+    const contentTypeService = strapi.plugins['content-type-builder'].services.contenttypes;
+
+    ctx.send({ data: contentTypeService.formatContentType(contentType) });
+  },
+
+  async createContentType(ctx) {
+    const { body } = ctx.request;
+
+    try {
+      await validateContentTypeInput(body);
+    } catch (error) {
+      return ctx.send({ error }, 400);
+    }
+
+    try {
+      strapi.reload.isWatching = false;
+
+      const contentTypeService = strapi.plugins['content-type-builder'].services.contenttypes;
+
+      const contentType = await contentTypeService.createContentType({
+        contentType: body.contentType,
+        components: body.components,
+      });
+
+      // const metricsProperties = {
+      //   kind: contentType.kind,
+      //   hasDraftAndPublish: hasDraftAndPublish(contentType.schema),
+      // };
+
+      /*  if (_.isEmpty(strapi.api)) {
+        await strapi.telemetry.send('didCreateFirstContentType', metricsProperties);
+      } else {
+        await strapi.telemetry.send('didCreateContentType', metricsProperties);
+      } */
+
+      setImmediate(() => strapi.reload());
+
+      ctx.send({ data: { uid: contentType.uid } }, 201);
+    } catch (error) {
+      strapi.log.error(error);
+      // await strapi.telemetry.send('didNotCreateContentType', { error: error.message });
+      ctx.send({ error: error.message }, 400);
+    }
+  },
+
+  async updateContentType(ctx) {
+    const { uid } = ctx.params;
+    const { body } = ctx.request;
+
+    if (!_.has(strapi.contentTypes, uid)) {
+      return ctx.send({ error: 'contentType.notFound' }, 404);
+    }
+
+    try {
+      await validateUpdateContentTypeInput(body);
+    } catch (error) {
+      return ctx.send({ error }, 400);
+    }
+
+    try {
+      strapi.reload.isWatching = false;
+
+      const contentTypeService = strapi.plugins['content-type-builder'].services.contenttypes;
+
+      const component = await contentTypeService.editContentType(uid, {
+        contentType: body.contentType,
+        components: body.components,
+      });
+
+      setImmediate(() => strapi.reload());
+
+      ctx.send({ data: { uid: component.uid } }, 201);
+    } catch (error) {
+      strapi.log.error(error);
+      ctx.send({ error: error.message }, 400);
+    }
+  },
+
+  async deleteContentType(ctx) {
+    const { uid } = ctx.params;
+
+    if (!_.has(strapi.contentTypes, uid)) {
+      return ctx.send({ error: 'contentType.notFound' }, 404);
+    }
+
+    try {
+      strapi.reload.isWatching = false;
+
+      const contentTypeService = strapi.plugins['content-type-builder'].services.contenttypes;
+
+      const component = await contentTypeService.deleteContentType(uid);
+
+      setImmediate(() => strapi.reload());
+
+      ctx.send({ data: { uid: component.uid } });
+    } catch (error) {
+      strapi.log.error(error);
+      ctx.send({ error: error.message }, 400);
+    }
+  },
+};

package/controllers/validation/common.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const yup = require('yup');
+const _ = require('lodash');
+
+const validators = {
+  required: yup.boolean(),
+  unique: yup.boolean(),
+  minLength: yup
+    .number()
+    .integer()
+    .positive(),
+  maxLength: yup
+    .number()
+    .integer()
+    .positive(),
+};
+
+const NAME_REGEX = new RegExp('^[A-Za-z][_0-9A-Za-z]*$');
+const COLLECTION_NAME_REGEX = new RegExp('^[A-Za-z][-_0-9A-Za-z]*$');
+const CATEGORY_NAME_REGEX = new RegExp('^[A-Za-z][-_0-9A-Za-z]*$');
+const ENUM_REGEX = new RegExp('^[_A-Za-z][_0-9A-Za-z]*$');
+const ICON_REGEX = new RegExp('^[A-Za-z0-9][-A-Za-z0-9]*$');
+const UID_REGEX = new RegExp('^[A-Za-z0-9-_.~]*$');
+
+const isValidName = {
+  name: 'isValidName',
+  message: '${path} must match the following regex: ' + NAME_REGEX,
+  test: val => val === '' || NAME_REGEX.test(val),
+};
+
+const isValidUID = {
+  name: 'isValidUID',
+  message: '${path} must match the following regex: ' + UID_REGEX,
+  test: val => val === '' || UID_REGEX.test(val),
+};
+
+const isValidCategoryName = {
+  name: 'isValidCategoryName',
+  message: '${path} must match the following regex: ' + CATEGORY_NAME_REGEX,
+  test: val => val === '' || CATEGORY_NAME_REGEX.test(val),
+};
+
+const isValidCollectionName = {
+  name: 'isValidCollectionName',
+  message: '${path} must match the following regex: ' + COLLECTION_NAME_REGEX,
+  test: val => val === '' || COLLECTION_NAME_REGEX.test(val),
+};
+
+const isValidIcon = {
+  name: 'isValidIcon',
+  message: '${path} must match the following regex: ' + ICON_REGEX,
+  test: val => val === '' || ICON_REGEX.test(val),
+};
+
+const isValidKey = key => ({
+  name: 'isValidKey',
+  message: `Attribute name '${key}' must match the following regex: ${NAME_REGEX}`,
+  test: () => NAME_REGEX.test(key),
+});
+
+const isValidEnum = {
+  name: 'isValidEnum',
+  message: '${path} must match the following regex: ' + ENUM_REGEX,
+  test: val => val === '' || ENUM_REGEX.test(val),
+};
+
+const areEnumValuesUnique = {
+  name: 'areEnumValuesUnique',
+  message: '${path} cannot contain duplicate values',
+  test: values => {
+    const filtered = [...new Set(values)];
+
+    return filtered.length === values.length;
+  },
+};
+
+const isValidRegExpPattern = {
+  name: 'isValidRegExpPattern',
+  message: '${path} must be a valid RexExp pattern string',
+  test: val => val === '' || new RegExp(val),
+};
+
+const isValidDefaultJSON = {
+  name: 'isValidDefaultJSON',
+  message: '${path} is not a valid JSON',
+  test: val => {
+    if (val === undefined) {
+      return true;
+    }
+
+    if (_.isNumber(val) || _.isNull(val) || _.isObject(val) || _.isArray(val)) {
+      return true;
+    }
+
+    try {
+      JSON.parse(val);
+
+      return true;
+    } catch (err) {
+      return false;
+    }
+  },
+};
+
+module.exports = {
+  validators,
+  areEnumValuesUnique,
+  isValidCollectionName,
+  isValidCategoryName,
+  isValidDefaultJSON,
+  isValidName,
+  isValidIcon,
+  isValidKey,
+  isValidEnum,
+  isValidUID,
+  isValidRegExpPattern,
+};

package/controllers/validation/component-category.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const yup = require('yup');
+const { formatYupErrors } = require('@akemona-org/strapi-utils');
+
+const { isValidCategoryName } = require('./common');
+
+module.exports = (data) => {
+  return componentCategorySchema
+    .validate(data, {
+      strict: true,
+      abortEarly: false,
+    })
+    .catch((error) => Promise.reject(formatYupErrors(error)));
+};
+
+const componentCategorySchema = yup
+  .object({
+    name: yup.string().min(3).test(isValidCategoryName).required('name.required'),
+  })
+  .noUnknown();

package/controllers/validation/component.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const _ = require('lodash');
+const yup = require('yup');
+const { formatYupErrors } = require('@akemona-org/strapi-utils');
+
+const { modelTypes, DEFAULT_TYPES } = require('../../services/constants');
+const { isValidCategoryName, isValidIcon } = require('./common');
+const createSchema = require('./model-schema');
+const { removeEmptyDefaults } = require('./data-transform');
+
+const VALID_RELATIONS = ['oneWay', 'manyWay'];
+const VALID_TYPES = [...DEFAULT_TYPES, 'component'];
+
+const componentSchema = createSchema(VALID_TYPES, VALID_RELATIONS, {
+  modelType: modelTypes.COMPONENT,
+})
+  .shape({
+    icon: yup.string().nullable().test(isValidIcon).required('icon.required'),
+    category: yup.string().nullable().test(isValidCategoryName).required('category.required'),
+  })
+  .required()
+  .noUnknown();
+
+const nestedComponentSchema = yup.array().of(
+  componentSchema
+    .shape({
+      uid: yup.string(),
+      tmpUID: yup.string(),
+    })
+    .test({
+      name: 'mustHaveUIDOrTmpUID',
+      message: 'Component must have a uid or a tmpUID',
+      test: (attr) => {
+        if (_.has(attr, 'uid') && _.has(attr, 'tmpUID')) return false;
+        if (!_.has(attr, 'uid') && !_.has(attr, 'tmpUID')) return false;
+        return true;
+      },
+    })
+    .required()
+    .noUnknown()
+);
+
+const validateComponentInput = (data) => {
+  return yup
+    .object({
+      component: componentSchema,
+      components: nestedComponentSchema,
+    })
+    .noUnknown()
+    .validate(data, {
+      strict: true,
+      abortEarly: false,
+    })
+    .catch((error) => Promise.reject(formatYupErrors(error)));
+};
+
+const validateUpdateComponentInput = (data) => {
+  if (_.has(data, 'component')) {
+    removeEmptyDefaults(data.component);
+  }
+
+  if (_.has(data, 'components') && Array.isArray(data.components)) {
+    data.components.forEach((data) => {
+      if (_.has(data, 'uid')) {
+        removeEmptyDefaults(data);
+      }
+    });
+  }
+
+  return yup
+    .object({
+      component: componentSchema,
+      components: nestedComponentSchema,
+    })
+    .noUnknown()
+    .validate(data, {
+      strict: true,
+      abortEarly: false,
+    })
+    .catch((error) => Promise.reject(formatYupErrors(error)));
+};
+
+module.exports = {
+  validateComponentInput,
+  validateUpdateComponentInput,
+
+  nestedComponentSchema,
+};

package/controllers/validation/content-type.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const _ = require('lodash');
+const yup = require('yup');
+const { formatYupErrors, nameToSlug } = require('@akemona-org/strapi-utils');
+const pluralize = require('pluralize');
+
+const { modelTypes, DEFAULT_TYPES, typeKinds } = require('../../services/constants');
+const createSchema = require('./model-schema');
+const { removeEmptyDefaults, removeDeletedUIDTargetFields } = require('./data-transform');
+const { nestedComponentSchema } = require('./component');
+
+/**
+ * Allowed relation per type kind
+ */
+const VALID_RELATIONS = {
+  [typeKinds.SINGLE_TYPE]: ['oneWay', 'manyWay'],
+  [typeKinds.COLLECTION_TYPE]: [
+    'oneWay',
+    'manyWay',
+    'oneToOne',
+    'oneToMany',
+    'manyToOne',
+    'manyToMany',
+  ],
+};
+
+/**
+ * Allowed types
+ */
+const VALID_TYPES = [...DEFAULT_TYPES, 'uid', 'component', 'dynamiczone'];
+
+/**
+ * Returns a yup schema to validate a content type payload
+ * @param {Object} data payload
+ */
+const createContentTypeSchema = (data, { isEdition = false } = {}) => {
+  const kind = _.get(data, 'contentType.kind', typeKinds.COLLECTION_TYPE);
+
+  const contentTypeSchema = createSchema(VALID_TYPES, VALID_RELATIONS[kind] || [], {
+    modelType: modelTypes.CONTENT_TYPE,
+  }).shape({
+    name: yup
+      .string()
+      .test(hasPluralName)
+      .test(alreadyUsedContentTypeName(isEdition))
+      .test(forbiddenContentTypeNameValidator())
+      .min(1)
+      .required(),
+  });
+
+  return yup
+    .object({
+      contentType: contentTypeSchema.required().noUnknown(),
+      components: nestedComponentSchema,
+    })
+    .noUnknown();
+};
+
+/**
+ * Validator for content type creation
+ */
+const validateContentTypeInput = (data) => {
+  return createContentTypeSchema(data)
+    .validate(data, {
+      strict: true,
+      abortEarly: false,
+    })
+    .catch((error) => Promise.reject(formatYupErrors(error)));
+};
+
+/**
+ * Validator for content type edition
+ */
+const validateUpdateContentTypeInput = (data) => {
+  if (_.has(data, 'contentType')) {
+    removeEmptyDefaults(data.contentType);
+  }
+
+  if (_.has(data, 'components') && Array.isArray(data.components)) {
+    data.components.forEach((data) => {
+      if (_.has(data, 'uid')) {
+        removeEmptyDefaults(data);
+      }
+    });
+  }
+
+  removeDeletedUIDTargetFields(data.contentType);
+
+  return createContentTypeSchema(data, { isEdition: true })
+    .validate(data, {
+      strict: true,
+      abortEarly: false,
+    })
+    .catch((error) => Promise.reject(formatYupErrors(error)));
+};
+
+const forbiddenContentTypeNameValidator = () => {
+  const reservedNames =
+    strapi.plugins['content-type-builder'].services.builder.getReservedNames().models;
+
+  return {
+    name: 'forbiddenContentTypeName',
+    message: `Content Type name cannot be one of ${reservedNames.join(', ')}`,
+    test: (value) => {
+      if (reservedNames.includes(nameToSlug(value))) {
+        return false;
+      }
+
+      return true;
+    },
+  };
+};
+
+const hasPluralName = {
+  name: 'hasPluralName',
+  message:
+    'Content Type name `${value}` cannot be pluralized. \nSuggestion: add Item after the name (e.g News -> NewsItem).',
+  test: (value) => {
+    if (pluralize.singular(value) === pluralize(value)) {
+      return false;
+    }
+
+    return true;
+  },
+};
+
+const alreadyUsedContentTypeName = (isEdition) => {
+  const usedNames = Object.values(strapi.contentTypes).map((ct) => ct.modelName);
+
+  return {
+    name: 'nameAlreadyUsed',
+    message: 'Content Type name `${value}` is already being used.',
+    test: (value) => {
+      // don't check on edition
+      if (isEdition) return true;
+
+      if (usedNames.includes(nameToSlug(value))) {
+        return false;
+      }
+      return true;
+    },
+  };
+};
+
+/**
+ * Validates type kind
+ */
+const validateKind = (kind) => {
+  return yup
+    .string()
+    .oneOf([typeKinds.SINGLE_TYPE, typeKinds.COLLECTION_TYPE])
+    .validate(kind)
+    .catch((error) => Promise.reject(formatYupErrors(error)));
+};
+
+module.exports = {
+  validateContentTypeInput,
+  validateUpdateContentTypeInput,
+  validateKind,
+};

package/controllers/validation/data-transform.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const _ = require('lodash');
+
+const removeEmptyDefaults = data => {
+  if (_.has(data, 'attributes')) {
+    Object.keys(data.attributes).forEach(attribute => {
+      if (data.attributes[attribute].default === '') {
+        data.attributes[attribute].default = undefined;
+      }
+    });
+  }
+};
+
+const removeDeletedUIDTargetFields = data => {
+  if (_.has(data, 'attributes')) {
+    Object.values(data.attributes).forEach(attribute => {
+      if (
+        attribute.type === 'uid' &&
+        !_.isUndefined(attribute.targetField) &&
+        !_.has(data.attributes, attribute.targetField)
+      ) {
+        attribute.targetField = undefined;
+      }
+    });
+  }
+};
+
+module.exports = {
+  removeDeletedUIDTargetFields,
+  removeEmptyDefaults,
+};

package/controllers/validation/model-schema.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const _ = require('lodash');
+const yup = require('yup');
+
+const { modelTypes, FORBIDDEN_ATTRIBUTE_NAMES, typeKinds } = require('../../services/constants');
+const { isValidCollectionName, isValidKey } = require('./common');
+const getTypeValidator = require('./types');
+const getRelationValidator = require('./relations');
+
+const createSchema = (types, relations, { modelType } = {}) => {
+  const shape = {
+    name: yup
+      .string()
+      .min(1)
+      .required('name.required'),
+    description: yup.string(),
+    draftAndPublish: yup.boolean(),
+    pluginOptions: yup.object(),
+    connection: yup.string(),
+    collectionName: yup
+      .string()
+      .nullable()
+      .test(isValidCollectionName),
+    attributes: createAttributesValidator({ types, relations, modelType }),
+  };
+
+  if (modelType === modelTypes.CONTENT_TYPE) {
+    shape.kind = yup
+      .string()
+      .oneOf([typeKinds.SINGLE_TYPE, typeKinds.COLLECTION_TYPE])
+      .nullable();
+  }
+
+  return yup.object(shape).noUnknown();
+};
+
+const createAttributesValidator = ({ types, modelType, relations }) => {
+  return yup.lazy(attributes => {
+    return yup
+      .object()
+      .shape(
+        _.mapValues(attributes, (attribute, key) => {
+          if (isForbiddenKey(key)) {
+            return forbiddenValidator();
+          }
+
+          if (_.has(attribute, 'type')) {
+            return getTypeValidator(attribute, { types, modelType, attributes }).test(
+              isValidKey(key)
+            );
+          }
+
+          if (_.has(attribute, 'target')) {
+            return yup.object(getRelationValidator(attribute, relations)).test(isValidKey(key));
+          }
+
+          return typeOrRelationValidator;
+        })
+      )
+      .required('attributes.required');
+  });
+};
+
+const isForbiddenKey = key => {
+  return [
+    ...FORBIDDEN_ATTRIBUTE_NAMES,
+    ...strapi.plugins['content-type-builder'].services.builder.getReservedNames().attributes,
+  ].includes(key);
+};
+
+const forbiddenValidator = () => {
+  const reservedNames = [
+    ...FORBIDDEN_ATTRIBUTE_NAMES,
+    ...strapi.plugins['content-type-builder'].services.builder.getReservedNames().attributes,
+  ];
+
+  return yup.mixed().test({
+    name: 'forbiddenKeys',
+    message: `Attribute keys cannot be one of ${reservedNames.join(', ')}`,
+    test: () => false,
+  });
+};
+
+const typeOrRelationValidator = yup.object().test({
+  name: 'mustHaveTypeOrTarget',
+  message: 'Attribute must have either a type or a target',
+  test: () => false,
+});
+
+module.exports = createSchema;