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

package/services/ContentTypes.js

@@ -0,0 +1,263 @@
+'use strict';
+
+const _ = require('lodash');
+const { getOr } = require('lodash/fp');
+const pluralize = require('pluralize');
+const generator = require('strapi-generate');
+
+const { nameToSlug, contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+const { formatAttributes, replaceTemporaryUIDs } = require('../utils/attributes');
+const createBuilder = require('./schema-builder');
+const apiHandler = require('./api-handler');
+const { coreUids, pluginsUids } = require('./constants');
+
+const isContentTypeVisible = (model) =>
+  getOr(true, 'pluginOptions.content-type-builder.visible', model) === true;
+
+const getRestrictRelationsTo = (contentType = {}) => {
+  const { uid } = contentType;
+  if (uid === coreUids.STRAPI_USER) {
+    return ['oneWay', 'manyWay'];
+  }
+
+  if (uid.startsWith(coreUids.PREFIX) || uid === pluginsUids.UPLOAD_FILE) {
+    return [];
+  }
+
+  return null;
+};
+
+const getformattedName = (contentType = {}) => {
+  const { uid, info } = contentType;
+  const name = _.get(info, 'name') || _.upperFirst(pluralize(uid));
+
+  return name;
+};
+
+/**
+ * Format a contentType info to be used by the front-end
+ * @param {Object} contentType
+ */
+const formatContentType = (contentType) => {
+  const { uid, kind, modelName, plugin, connection, collectionName, info, options } = contentType;
+
+  return {
+    uid,
+    plugin,
+    apiID: modelName,
+    schema: {
+      name: getformattedName(contentType),
+      description: _.get(info, 'description', ''),
+      draftAndPublish: contentTypesUtils.hasDraftAndPublish({ options }),
+      pluginOptions: contentType.pluginOptions,
+      connection,
+      kind: kind || 'collectionType',
+      collectionName,
+      attributes: formatAttributes(contentType),
+      visible: isContentTypeVisible(contentType),
+      restrictRelationsTo: getRestrictRelationsTo(contentType),
+    },
+  };
+};
+
+const createContentTypes = async (contentTypes) => {
+  const builder = createBuilder();
+  const createdContentTypes = [];
+
+  for (const contentType of contentTypes) {
+    createdContentTypes.push(await createContentType(contentType, { defaultBuilder: builder }));
+  }
+
+  await builder.writeFiles();
+
+  return createdContentTypes;
+};
+
+/**
+ * Creates a content type and handle the nested components sent with it
+ * @param {Object} params params object
+ * @param {Object} params.contentType Main component to create
+ * @param {Array<Object>} params.components List of nested components to created or edit
+ * @param {Object} options
+ * @param {Builder} options.defaultBuilder
+ */
+const createContentType = async ({ contentType, components = [] }, options = {}) => {
+  const builder = options.defaultBuilder || createBuilder();
+  const uidMap = builder.createNewComponentUIDMap(components);
+
+  const replaceTmpUIDs = replaceTemporaryUIDs(uidMap);
+
+  const newContentType = builder.createContentType(replaceTmpUIDs(contentType));
+
+  // allow components to target the new contentType
+  const targetContentType = (infos) => {
+    Object.keys(infos.attributes).forEach((key) => {
+      const { target } = infos.attributes[key];
+      if (target === '__contentType__') {
+        infos.attributes[key].target = newContentType.uid;
+      }
+    });
+
+    return infos;
+  };
+
+  components.forEach((component) => {
+    const options = replaceTmpUIDs(targetContentType(component));
+
+    if (!_.has(component, 'uid')) {
+      return builder.createComponent(options);
+    }
+
+    return builder.editComponent(options);
+  });
+
+  // generate api skeleton
+  await generateAPI({
+    name: contentType.name,
+    kind: contentType.kind,
+  });
+
+  if (!options.defaultBuilder) {
+    await builder.writeFiles();
+  }
+
+  return newContentType;
+};
+
+/**
+ * Generate an API squeleton
+ * @param {string} name
+ */
+const generateAPI = ({ name, kind = 'collectionType' }) => {
+  return new Promise((resolve, reject) => {
+    const scope = {
+      generatorType: 'api',
+      id: nameToSlug(name),
+      name: nameToSlug(name),
+      rootPath: strapi.dir,
+      args: {
+        attributes: {},
+        kind,
+      },
+    };
+
+    generator(scope, {
+      success: () => resolve(),
+      error: (err) => reject(err),
+    });
+  });
+};
+
+/**
+ * Edits a contentType and handle the nested contentTypes sent with it
+ * @param {String} uid Content-type's uid
+ * @param {Object} params params object
+ * @param {Object} params.contentType Main contentType to create
+ * @param {Array<Object>} params.components List of nested components to created or edit
+ */
+const editContentType = async (uid, { contentType, components = [] }) => {
+  const builder = createBuilder();
+
+  const previousKind = builder.contentTypes.get(uid).schema.kind;
+  const newKind = contentType.kind || previousKind;
+
+  if (newKind !== previousKind && newKind === 'singleType') {
+    const entryCount = await strapi.query(uid).count();
+    if (entryCount > 1) {
+      throw strapi.errors.badRequest(
+        'You cannot convert a collectionType to a singleType when having multiple entries in DB'
+      );
+    }
+  }
+
+  const uidMap = builder.createNewComponentUIDMap(components);
+  const replaceTmpUIDs = replaceTemporaryUIDs(uidMap);
+
+  const updatedContentType = builder.editContentType({
+    uid,
+    ...replaceTmpUIDs(contentType),
+  });
+
+  components.forEach((component) => {
+    if (!_.has(component, 'uid')) {
+      return builder.createComponent(replaceTmpUIDs(component));
+    }
+
+    return builder.editComponent(replaceTmpUIDs(component));
+  });
+
+  if (newKind !== previousKind) {
+    await apiHandler.backup(uid);
+
+    try {
+      await apiHandler.clear(uid);
+
+      // generate new api skeleton
+      await generateAPI({
+        name: updatedContentType.schema.info.name,
+        kind: updatedContentType.schema.kind,
+      });
+
+      await builder.writeFiles();
+    } catch (error) {
+      strapi.log.error(error);
+      await apiHandler.rollback(uid);
+    }
+
+    return updatedContentType;
+  }
+
+  await builder.writeFiles();
+  return updatedContentType;
+};
+
+const deleteContentTypes = async (uids) => {
+  const builder = createBuilder();
+
+  for (const uid of uids) {
+    await deleteContentType(uid, builder);
+  }
+
+  await builder.writeFiles();
+  for (const uid of uids) {
+    try {
+      await apiHandler.clear(uid);
+    } catch (error) {
+      strapi.log.error(error);
+      await apiHandler.rollback(uid);
+    }
+  }
+};
+
+/**
+ * Deletes a content type and the api files related to it
+ * @param {string} uid content type uid
+ * @param defaultBuilder
+ */
+const deleteContentType = async (uid, defaultBuilder = undefined) => {
+  const builder = defaultBuilder || createBuilder();
+  // make a backup
+  await apiHandler.backup(uid);
+
+  const contentType = builder.deleteContentType(uid);
+
+  if (!defaultBuilder) {
+    try {
+      await builder.writeFiles();
+      await apiHandler.clear(uid);
+    } catch (error) {
+      await apiHandler.rollback(uid);
+    }
+  }
+
+  return contentType;
+};
+
+module.exports = {
+  createContentType,
+  editContentType,
+  deleteContentType,
+  formatContentType,
+  createContentTypes,
+  deleteContentTypes,
+};

package/services/api-handler.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const path = require('path');
+const fse = require('fs-extra');
+const _ = require('lodash');
+
+/**
+ * Deletes the API folder of a contentType
+ * @param {string} uid content type uid
+ */
+async function clear(uid) {
+  const { apiName, __filename__ } = strapi.contentTypes[uid];
+
+  const apiFolder = path.join(strapi.dir, 'api', apiName);
+
+  // base name of the model file that will be use as comparator
+  const baseName = path.basename(__filename__, '.settings.json');
+
+  await recursiveRemoveFiles(apiFolder, createDeleteApiFunction(baseName));
+  await deleteBackup(uid);
+}
+
+/**
+ * Backups the API folder of a contentType
+ * @param {string} uid content type uid
+ */
+async function backup(uid) {
+  const { apiName } = strapi.contentTypes[uid];
+
+  const apiFolder = path.join(strapi.dir, 'api', apiName);
+  const backupFolder = path.join(strapi.dir, 'api', '.backup', apiName);
+
+  // backup the api folder
+  await fse.copy(apiFolder, backupFolder);
+}
+
+/**
+ * Deletes an API backup folder
+ * @param {string} uid content type uid
+ */
+async function deleteBackup(uid) {
+  const { apiName } = strapi.contentTypes[uid];
+
+  const backupFolder = path.join(strapi.dir, 'api', '.backup');
+  const apiBackupFolder = path.join(strapi.dir, 'api', '.backup', apiName);
+
+  await fse.remove(apiBackupFolder);
+
+  const list = await fse.readdir(backupFolder);
+  if (list.length === 0) {
+    await fse.remove(backupFolder);
+  }
+}
+
+/**
+ * Rollbacks the API folder of a contentType
+ * @param {string} uid content type uid
+ */
+async function rollback(uid) {
+  const { apiName } = strapi.contentTypes[uid];
+
+  const apiFolder = path.join(strapi.dir, 'api', apiName);
+  const backupFolder = path.join(strapi.dir, 'api', '.backup', apiName);
+
+  const exists = await fse.exists(backupFolder);
+
+  if (!exists) {
+    throw new Error('Cannot rollback api that was not backed up');
+  }
+
+  await fse.remove(apiFolder);
+  await fse.copy(backupFolder, apiFolder);
+  await deleteBackup(uid);
+}
+
+/**
+ * Creates a delete function to clear an api folder
+ * @param {string} baseName
+ */
+const createDeleteApiFunction = baseName => {
+  const startWithBaseName = startWithName(baseName + '.');
+
+  /**
+   * Delets a file in an api.
+   * Will only update routes.json instead of deleting it if other routes are present
+   * @param {string} filePath file path to delete
+   */
+  return async filePath => {
+    const fileName = path.basename(filePath);
+
+    if (startWithBaseName(fileName)) return fse.remove(filePath);
+
+    if (fileName === 'routes.json') {
+      const { routes } = await fse.readJSON(filePath);
+
+      const routesToKeep = routes.filter(route => !startWithBaseName(route.handler));
+
+      if (routesToKeep.length === 0) {
+        return fse.remove(filePath);
+      }
+
+      await fse.writeJSON(
+        filePath,
+        {
+          routes: routesToKeep,
+        },
+        {
+          spaces: 2,
+        }
+      );
+    }
+  };
+};
+
+/**
+ * Returns a function that checks if the passed string starts with the name
+ * @param {string} prefix
+ * @returns {Function} a comparing function
+ */
+const startWithName = prefix => {
+  /**
+   * Checks if str starts with prefix case insensitive
+   * @param {string} str string to compare
+   */
+  return str => _.startsWith(_.toLower(str), _.toLower(prefix));
+};
+
+/**
+ * Deletes a folder recursively using a delete function
+ * @param {string} folder folder to delete
+ * @param {Function} deleteFn function to call with the file path to delete
+ */
+const recursiveRemoveFiles = async (folder, deleteFn) => {
+  const filesName = await fse.readdir(folder);
+
+  for (const fileName of filesName) {
+    const filePath = path.join(folder, fileName);
+
+    const stat = await fse.stat(filePath);
+
+    if (stat.isDirectory()) {
+      await recursiveRemoveFiles(filePath, deleteFn);
+    } else {
+      await deleteFn(filePath);
+    }
+  }
+
+  const files = await fse.readdir(folder);
+  if (files.length === 0) {
+    await fse.remove(folder);
+  }
+};
+
+module.exports = {
+  clear,
+  backup,
+  rollback,
+};

package/services/constants.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const CONTENT_TYPE = 'CONTENT_TYPE';
+const COMPONENT = 'COMPONENT';
+
+const SINGLE_TYPE = 'singleType';
+const COLLECTION_TYPE = 'collectionType';
+
+const DEFAULT_TYPES = [
+  // advanced types
+  'media',
+
+  // scalar types
+  'string',
+  'text',
+  'richtext',
+  'json',
+  'enumeration',
+  'password',
+  'email',
+  'integer',
+  'biginteger',
+  'float',
+  'decimal',
+  'date',
+  'time',
+  'datetime',
+  'timestamp',
+  'boolean',
+];
+
+const VALID_UID_TARGETS = ['string', 'text'];
+
+const FORBIDDEN_ATTRIBUTE_NAMES = ['__component', '__contentType'];
+
+const PREFIX = 'strapi::';
+const STRAPI_USER = 'strapi::user';
+const UPLOAD_FILE = 'plugins::upload.file';
+
+module.exports = {
+  DEFAULT_TYPES,
+  typeKinds: {
+    SINGLE_TYPE,
+    COLLECTION_TYPE,
+  },
+  modelTypes: {
+    CONTENT_TYPE,
+    COMPONENT,
+  },
+  FORBIDDEN_ATTRIBUTE_NAMES,
+  VALID_UID_TARGETS,
+  coreUids: {
+    STRAPI_USER,
+    PREFIX,
+  },
+  pluginsUids: {
+    UPLOAD_FILE,
+  },
+};

package/services/schema-builder/component-builder.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const path = require('path');
+const _ = require('lodash');
+const pluralize = require('pluralize');
+
+const { nameToSlug, nameToCollectionName } = require('@akemona-org/strapi-utils');
+const { isConfigurable } = require('../../utils/attributes');
+const createSchemaHandler = require('./schema-handler');
+
+module.exports = function createComponentBuilder() {
+  return {
+    /**
+     * Returns a uid from a component infos
+     * @param {Object} options options
+     * @param {string} options.category component category
+     * @param {string} options.name component name
+     */
+    createComponentUID({ category, name }) {
+      return `${nameToSlug(category)}.${nameToSlug(name)}`;
+    },
+
+    createNewComponentUIDMap(components) {
+      return components.reduce((uidMap, component) => {
+        uidMap[component.tmpUID] = this.createComponentUID(component);
+        return uidMap;
+      }, {});
+    },
+
+    /**
+     * create a component in the tmpComponent map
+     */
+    createComponent(infos) {
+      const uid = this.createComponentUID(infos);
+
+      if (this.components.has(uid)) {
+        throw new Error('component.alreadyExists');
+      }
+
+      const handler = createSchemaHandler({
+        dir: path.join(strapi.dir, 'components', nameToSlug(infos.category)),
+        filename: `${nameToSlug(infos.name)}.json`,
+      });
+
+      const defaultCollectionName = `components_${nameToCollectionName(
+        infos.category
+      )}_${nameToCollectionName(pluralize(infos.name))}`;
+
+      handler
+        .setUID(uid)
+        .set('collectionName', infos.collectionName || defaultCollectionName)
+        .set(['info', 'name'], infos.name)
+        .set(['info', 'icon'], infos.icon)
+        .set(['info', 'description'], infos.description)
+        .set('pluginOptions', infos.pluginOptions)
+        .setAttributes(this.convertAttributes(infos.attributes));
+
+      /*  if (this.components.size === 0) {
+        strapi.telemetry.send('didCreateFirstComponent');
+      } else {
+        strapi.telemetry.send('didCreateComponent');
+      } */
+
+      this.components.set(uid, handler);
+
+      return handler;
+    },
+
+    /**
+     * create a component in the tmpComponent map
+     */
+    editComponent(infos) {
+      const { uid } = infos;
+
+      if (!this.components.has(uid)) {
+        throw new Error('component.notFound');
+      }
+
+      const component = this.components.get(uid);
+
+      const [, nameUID] = uid.split('.');
+
+      const newCategory = nameToSlug(infos.category);
+      const newUID = `${newCategory}.${nameUID}`;
+
+      if (newUID !== uid && this.components.has(newUID)) {
+        throw new Error('component.edit.alreadyExists');
+      }
+
+      const newDir = path.join(strapi.dir, 'components', newCategory);
+
+      const oldAttributes = component.schema.attributes;
+
+      const newAttributes = _.omitBy(infos.attributes, (attr, key) => {
+        return _.has(oldAttributes, key) && !isConfigurable(oldAttributes[key]);
+      });
+
+      component
+        .setUID(newUID)
+        .setDir(newDir)
+        .set('collectionName', infos.collectionName)
+        .set(['info', 'name'], infos.name)
+        .set(['info', 'icon'], infos.icon)
+        .set(['info', 'description'], infos.description)
+        .set('pluginOptions', infos.pluginOptions)
+        .setAttributes(this.convertAttributes(newAttributes));
+
+      if (newUID !== uid) {
+        this.components.forEach((compo) => {
+          compo.updateComponent(uid, newUID);
+        });
+
+        this.contentTypes.forEach((ct) => {
+          ct.updateComponent(uid, newUID);
+        });
+      }
+
+      return component;
+    },
+
+    deleteComponent(uid) {
+      if (!this.components.has(uid)) {
+        throw new Error('component.notFound');
+      }
+
+      this.components.forEach((compo) => {
+        compo.removeComponent(uid);
+      });
+
+      this.contentTypes.forEach((ct) => {
+        ct.removeComponent(uid);
+      });
+
+      return this.components.get(uid).delete();
+    },
+  };
+};