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

package/controllers/validation/relations.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const yup = require('yup');
+const { typeKinds, coreUids } = require('../../services/constants');
+const { validators, isValidName } = require('./common');
+
+const REVERSE_RELATIONS = ['oneToOne', 'oneToMany', 'manyToOne', 'manyToMany'];
+const STRAPI_USER_RELATIONS = ['oneWay', 'manyWay'];
+
+const isValidNature = validNatures =>
+  function(value) {
+    const allowedRelations =
+      this.parent.target === coreUids.STRAPI_USER ? STRAPI_USER_RELATIONS : validNatures;
+
+    return allowedRelations.includes(value)
+      ? true
+      : this.createError({
+          path: this.path,
+          message: `must be one of the following values: ${allowedRelations.join(', ')}`,
+        });
+  };
+
+module.exports = (obj, validNatures) => {
+  const contentTypesUIDs = Object.keys(strapi.contentTypes)
+    .filter(key => strapi.contentTypes[key].kind === typeKinds.COLLECTION_TYPE)
+    .filter(key => !key.startsWith(coreUids.PREFIX) || key === coreUids.STRAPI_USER)
+    .concat(['__self__', '__contentType__']);
+
+  return {
+    target: yup
+      .string()
+      .oneOf(contentTypesUIDs)
+      .required(),
+    nature: yup
+      .string()
+      .test('isValidNature', isValidNature(validNatures))
+      .required(),
+    unique: validators.unique.nullable(),
+    configurable: yup.boolean().nullable(),
+    autoPopulate: yup.boolean().nullable(),
+    dominant: yup.boolean().nullable(),
+    columnName: yup.string().nullable(),
+    targetAttribute: REVERSE_RELATIONS.includes(obj.nature)
+      ? yup
+          .string()
+          .test(isValidName)
+          .required()
+      : yup
+          .string()
+          .test(isValidName)
+          .nullable(),
+    targetColumnName: yup.string().nullable(),
+    private: yup.boolean().nullable(),
+    pluginOptions: yup.object(),
+  };
+};

package/controllers/validation/types.js

@@ -0,0 +1,277 @@
+'use strict';
+
+const _ = require('lodash');
+const yup = require('yup');
+
+const { hasComponent } = require('../../utils/attributes');
+const { modelTypes, VALID_UID_TARGETS } = require('../../services/constants');
+const {
+  validators,
+  areEnumValuesUnique,
+  isValidDefaultJSON,
+  isValidName,
+  isValidEnum,
+  isValidUID,
+  isValidRegExpPattern,
+} = require('./common');
+
+const maxLengthIsGreaterThanOrEqualToMinLength = {
+  name: 'isGreaterThanMin',
+  message: 'maxLength must be greater or equal to minLength',
+  test: function(value) {
+    const { minLength } = this.parent;
+    if (!_.isUndefined(minLength) && !_.isUndefined(value) && value < minLength) {
+      return false;
+    }
+
+    return true;
+  },
+};
+
+const getTypeValidator = (attribute, { types, modelType, attributes }) => {
+  return yup.object({
+    type: yup
+      .string()
+      .oneOf(types)
+      .required(),
+    configurable: yup.boolean().nullable(),
+    private: yup.boolean().nullable(),
+    pluginOptions: yup.object(),
+    ...getTypeShape(attribute, { modelType, attributes }),
+  });
+};
+
+const getTypeShape = (attribute, { modelType, attributes } = {}) => {
+  switch (attribute.type) {
+    /**
+     * complexe types
+     */
+
+    case 'media': {
+      return {
+        multiple: yup.boolean(),
+        required: validators.required,
+        unique: validators.unique,
+        allowedTypes: yup
+          .array()
+          .of(yup.string().oneOf(['images', 'videos', 'files']))
+          .min(1),
+      };
+    }
+
+    case 'uid': {
+      return {
+        required: validators.required,
+        targetField: yup
+          .string()
+          .oneOf(
+            Object.keys(attributes).filter(key =>
+              VALID_UID_TARGETS.includes(_.get(attributes[key], 'type'))
+            )
+          )
+          .nullable(),
+        default: yup
+          .string()
+          .test(
+            'isValidDefaultUID',
+            'cannot define a default UID if the targetField is set',
+            function(value) {
+              const { targetField } = this.parent;
+              if (_.isNil(targetField) || _.isNil(value)) {
+                return true;
+              }
+
+              return false;
+            }
+          )
+          .test(isValidUID),
+        minLength: validators.minLength,
+        maxLength: validators.maxLength.max(256).test(maxLengthIsGreaterThanOrEqualToMinLength),
+        options: yup.object().shape({
+          separator: yup.string(),
+          lowercase: yup.boolean(),
+          decamelize: yup.boolean(),
+          customReplacements: yup.array().of(
+            yup
+              .array()
+              .of(yup.string())
+              .min(2)
+              .max(2)
+          ),
+          preserveLeadingUnderscore: yup.boolean(),
+        }),
+      };
+    }
+
+    /**
+     * scalar types
+     */
+    case 'string':
+    case 'text': {
+      return {
+        default: yup.string(),
+        required: validators.required,
+        unique: validators.unique,
+        minLength: validators.minLength,
+        maxLength: validators.maxLength,
+        regex: yup.string().test(isValidRegExpPattern),
+      };
+    }
+    case 'richtext': {
+      return {
+        default: yup.string(),
+        required: validators.required,
+        minLength: validators.minLength,
+        maxLength: validators.maxLength,
+      };
+    }
+    case 'json': {
+      return {
+        default: yup.mixed().test(isValidDefaultJSON),
+        required: validators.required,
+        unique: validators.unique,
+      };
+    }
+    case 'enumeration': {
+      return {
+        enum: yup
+          .array()
+          .of(
+            yup
+              .string()
+              .test(isValidEnum)
+              .required()
+          )
+          .min(1)
+          .test(areEnumValuesUnique)
+          .required(),
+        default: yup.string().when('enum', enumVal => yup.string().oneOf(enumVal)),
+        enumName: yup.string().test(isValidName),
+        required: validators.required,
+        unique: validators.unique,
+      };
+    }
+    case 'password': {
+      return {
+        required: validators.required,
+        minLength: validators.minLength,
+        maxLength: validators.maxLength,
+      };
+    }
+    case 'email': {
+      return {
+        default: yup.string().email(),
+        required: validators.required,
+        unique: validators.unique,
+        minLength: validators.minLength,
+        maxLength: validators.maxLength,
+      };
+    }
+    case 'integer': {
+      return {
+        default: yup.number().integer(),
+        required: validators.required,
+        unique: validators.unique,
+        min: yup.number().integer(),
+        max: yup.number().integer(),
+      };
+    }
+    case 'biginteger': {
+      return {
+        default: yup
+          .string()
+          .nullable()
+          .matches(/^\d*$/),
+        required: validators.required,
+        unique: validators.unique,
+        min: yup
+          .string()
+          .nullable()
+          .matches(/^\d*$/),
+        max: yup
+          .string()
+          .nullable()
+          .matches(/^\d*$/),
+      };
+    }
+    case 'float': {
+      return {
+        default: yup.number(),
+        required: validators.required,
+        unique: validators.unique,
+        min: yup.number(),
+        max: yup.number(),
+      };
+    }
+    case 'decimal': {
+      return {
+        default: yup.number(),
+        required: validators.required,
+        unique: validators.unique,
+        min: yup.number(),
+        max: yup.number(),
+      };
+    }
+    case 'time':
+    case 'datetime':
+    case 'date': {
+      return {
+        default: yup.string(),
+        required: validators.required,
+        unique: validators.unique,
+      };
+    }
+    case 'boolean': {
+      return {
+        default: yup.boolean(),
+        required: validators.required,
+        unique: validators.unique,
+      };
+    }
+
+    case 'component': {
+      return {
+        required: validators.required,
+        repeatable: yup.boolean(),
+        component: yup
+          .string()
+          .test({
+            name: 'Check max component nesting is 1 lvl',
+            test: function(compoUID) {
+              const targetCompo = strapi.components[compoUID];
+              if (!targetCompo) return true; // ignore this error as it will fail beforehand
+
+              if (modelType === modelTypes.COMPONENT && hasComponent(targetCompo)) {
+                return this.createError({
+                  path: this.path,
+                  message: `${targetCompo.modelName} already is a nested component. You cannot have more than one level of nesting inside your components.`,
+                });
+              }
+              return true;
+            },
+          })
+          .required(),
+        min: yup.number(),
+        max: yup.number(),
+      };
+    }
+
+    case 'dynamiczone': {
+      return {
+        required: validators.required,
+        components: yup
+          .array()
+          .of(yup.string().required())
+          .test('isArray', '${path} must be an array', value => Array.isArray(value)),
+        min: yup.number(),
+        max: yup.number(),
+      };
+    }
+
+    default: {
+      return {};
+    }
+  }
+};
+
+module.exports = getTypeValidator;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@akemona-org/strapi-plugin-content-type-builder",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "3.7.0",
+  "description": "Strapi plugin to create content type (API).",
+  "strapi": {
+    "name": "Content Type Builder",
+    "icon": "paint-brush",
+    "description": "content-type-builder.plugin.description"
+  },
+  "dependencies": {
+    "@akemona-org/strapi-generate": "3.7.0",
+    "@akemona-org/strapi-generate-api": "3.7.0",
+    "@akemona-org/strapi-helper-plugin": "3.7.0",
+    "@akemona-org/strapi-utils": "3.7.0",
+    "@buffetjs/core": "3.3.8",
+    "@buffetjs/custom": "3.3.8",
+    "@buffetjs/hooks": "3.3.8",
+    "@buffetjs/icons": "3.3.8",
+    "@buffetjs/styles": "3.3.8",
+    "@buffetjs/utils": "3.3.8",
+    "@sindresorhus/slugify": "1.1.0",
+    "fs-extra": "^9.1.0",
+    "immutable": "^3.8.2",
+    "lodash": "4.17.21",
+    "pluralize": "^8.0.0",
+    "react": "^16.14.0",
+    "react-dom": "^16.9.0",
+    "react-intl": "4.5.0",
+    "react-redux": "7.2.3",
+    "react-router": "^5.2.0",
+    "react-router-dom": "^5.0.0",
+    "reactstrap": "8.4.1",
+    "redux": "^4.0.1",
+    "redux-immutable": "^4.0.0",
+    "reselect": "^4.0.0",
+    "yup": "^0.32.9"
+  },
+  "author": {
+    "name": "Akemona team",
+    "email": "strapi@akemona.com",
+    "url": "https://strapi.akemona.com"
+  },
+  "maintainers": [
+    {
+      "name": "Akemona team",
+      "email": "strapi@akemona.com",
+      "url": "https://strapi.akemona.com"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/akemona/strapi.git"
+  },
+  "engines": {
+    "node": ">=10.16.0 <=14.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "gitHead": "129a8d6191b55810fd66448dcc47fee829df986c"
+}

package/services/Builder.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  getReservedNames() {
+    return strapi.db.getReservedNames();
+  },
+};

package/services/ComponentCategories.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const { join } = require('path');
+
+const { nameToSlug } = require('@akemona-org/strapi-utils');
+const createBuilder = require('./schema-builder');
+
+/**
+ * Edit a category name and move components to the write folder
+ * @param {string} name category name
+ * @param {Object} infos new category data
+ */
+const editCategory = async (name, infos) => {
+  const componentsDir = join(strapi.dir, 'components');
+  const newName = nameToSlug(infos.name);
+
+  // don't do anything the name doesn't change
+  if (name === newName) return;
+
+  if (!categoryExists(name)) {
+    throw strapi.errors.notFound('cateogry.notFound');
+  }
+
+  if (categoryExists(newName)) {
+    throw strapi.errors.badRequest('Name already taken');
+  }
+
+  const builder = createBuilder();
+
+  builder.components.forEach((component) => {
+    const oldUID = component.uid;
+    const newUID = `${newName}.${component.modelName}`;
+
+    // only edit the components in this specific category
+    if (component.category !== name) return;
+
+    component.setUID(newUID).setDir(join(componentsDir, newName));
+
+    builder.components.forEach((compo) => {
+      compo.updateComponent(oldUID, newUID);
+    });
+
+    builder.contentTypes.forEach((ct) => {
+      ct.updateComponent(oldUID, newUID);
+    });
+  });
+
+  await builder.writeFiles();
+
+  return newName;
+};
+
+/**
+ * Deletes a category and its components
+ * @param {string} name category name to delete
+ */
+const deleteCategory = async (name) => {
+  if (!categoryExists(name)) {
+    throw strapi.errors.notFound('cateogry.notFound');
+  }
+
+  const builder = createBuilder();
+
+  builder.components.forEach((component) => {
+    if (component.category === name) {
+      builder.deleteComponent(component.uid);
+    }
+  });
+
+  await builder.writeFiles();
+};
+
+/**
+ * Checks if a category exists
+ * @param {string} name category name to serach for
+ */
+const categoryExists = (name) => {
+  const matchingIndex = Object.values(strapi.components).findIndex(
+    (component) => component.category === name
+  );
+
+  return matchingIndex > -1;
+};
+
+module.exports = {
+  editCategory,
+  deleteCategory,
+};

package/services/Components.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const _ = require('lodash');
+const pluralize = require('pluralize');
+
+const { formatAttributes, replaceTemporaryUIDs } = require('../utils/attributes');
+const createBuilder = require('./schema-builder');
+
+/**
+ * Formats a component attributes
+ * @param {string} uid - string
+ * @param {Object} component - strapi component model
+ */
+const formatComponent = component => {
+  const { uid, modelName, connection, collectionName, info, category } = component;
+
+  return {
+    uid,
+    category,
+    apiId: modelName,
+    schema: {
+      icon: _.get(info, 'icon'),
+      name: _.get(info, 'name') || _.upperFirst(pluralize(uid)),
+      description: _.get(info, 'description', ''),
+      connection,
+      collectionName,
+      pluginOptions: component.pluginOptions,
+      attributes: formatAttributes(component),
+    },
+  };
+};
+
+/**
+ * Creates a component and handle the nested components sent with it
+ * @param {Object} params params object
+ * @param {Object} params.component Main component to create
+ * @param {Array<Object>} params.components List of nested components to created or edit
+ */
+const createComponent = async ({ component, components = [] }) => {
+  const builder = createBuilder();
+
+  const uidMap = builder.createNewComponentUIDMap(components);
+  const replaceTmpUIDs = replaceTemporaryUIDs(uidMap);
+
+  const newComponent = builder.createComponent(replaceTmpUIDs(component));
+
+  components.forEach(component => {
+    if (!_.has(component, 'uid')) {
+      return builder.createComponent(replaceTmpUIDs(component));
+    }
+
+    return builder.editComponent(replaceTmpUIDs(component));
+  });
+
+  await builder.writeFiles();
+  return newComponent;
+};
+
+/**
+ * Edits a component and handle the nested components sent with it
+ * @param {Object} params params object
+ * @param {Object} params.component Main component to create
+ * @param {Array<Object>} params.components List of nested components to created or edit
+ */
+const editComponent = async (uid, { component, components = [] }) => {
+  const builder = createBuilder();
+
+  const uidMap = builder.createNewComponentUIDMap(components);
+  const replaceTmpUIDs = replaceTemporaryUIDs(uidMap);
+
+  const updatedComponent = builder.editComponent({
+    uid,
+    ...replaceTmpUIDs(component),
+  });
+
+  components.forEach(component => {
+    if (!_.has(component, 'uid')) {
+      return builder.createComponent(replaceTmpUIDs(component));
+    }
+
+    return builder.editComponent(replaceTmpUIDs(component));
+  });
+
+  await builder.writeFiles();
+  return updatedComponent;
+};
+
+const deleteComponent = async uid => {
+  const builder = createBuilder();
+
+  const deletedComponent = builder.deleteComponent(uid);
+
+  await builder.writeFiles();
+  return deletedComponent;
+};
+
+module.exports = {
+  createComponent,
+  editComponent,
+  deleteComponent,
+
+  formatComponent,
+};