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

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

@@ -0,0 +1,297 @@
+'use strict';
+
+const path = require('path');
+const fse = require('fs-extra');
+const _ = require('lodash');
+const { toUID, isConfigurable } = require('../../utils/attributes');
+
+module.exports = function createSchemaHandler(infos) {
+  const { category, modelName, plugin, uid, dir, filename, schema } = infos;
+
+  const initialState = {
+    modelName,
+    plugin,
+    category,
+    uid,
+    dir,
+    filename,
+    schema: schema || {
+      info: {},
+      options: {},
+      attributes: {},
+    },
+  };
+
+  const state = _.cloneDeep(initialState);
+
+  // always keep it the same to rollback
+  Object.freeze(initialState.schema);
+
+  let modified = false;
+  let deleted = false;
+
+  return {
+    get modelName() {
+      return initialState.modelName;
+    },
+
+    get plugin() {
+      return initialState.plugin;
+    },
+
+    get category() {
+      return initialState.category;
+    },
+
+    get kind() {
+      return _.get(state.schema, 'kind', 'collectionType');
+    },
+
+    get uid() {
+      return state.uid;
+    },
+
+    get writable() {
+      return _.get(state, 'plugin') !== 'admin';
+    },
+
+    setUID(val) {
+      modified = true;
+
+      state.uid = val;
+      return this;
+    },
+
+    setDir(val) {
+      modified = true;
+
+      state.dir = val;
+      return this;
+    },
+
+    get schema() {
+      return _.cloneDeep(state.schema);
+    },
+
+    setSchema(val) {
+      modified = true;
+
+      state.schema = _.cloneDeep(val);
+      return this;
+    },
+
+    // get a particuar path inside the schema
+    get(path) {
+      return _.get(state.schema, path);
+    },
+
+    // set a particuar path inside the schema
+    set(path, val) {
+      modified = true;
+
+      const value = _.defaultTo(val, _.get(state.schema, path));
+      _.set(state.schema, path, value);
+
+      return this;
+    },
+
+    // delete a particuar path inside the schema
+    unset(path) {
+      modified = true;
+
+      _.unset(state.schema, path);
+
+      return this;
+    },
+
+    delete() {
+      deleted = true;
+      return this;
+    },
+
+    getAttribute(key) {
+      return this.get(['attributes', key]);
+    },
+
+    setAttribute(key, attribute) {
+      return this.set(['attributes', key], attribute);
+    },
+
+    deleteAttribute(key) {
+      return this.unset(['attributes', key]);
+    },
+
+    setAttributes(newAttributes) {
+      // delete old configurable attributes
+      for (let key in this.schema.attributes) {
+        if (isConfigurable(this.schema.attributes[key])) {
+          this.deleteAttribute(key);
+        }
+      }
+
+      // set new Attributes
+      for (let key in newAttributes) {
+        this.setAttribute(key, newAttributes[key]);
+      }
+
+      return this;
+    },
+
+    removeContentType(uid) {
+      const { attributes } = state.schema;
+
+      Object.keys(attributes).forEach(key => {
+        const attr = attributes[key];
+        const target = attr.model || attr.collection;
+        const plugin = attr.plugin;
+
+        const relationUID = toUID(target, plugin);
+
+        if (relationUID === uid) {
+          this.deleteAttribute(key);
+        }
+      });
+
+      return this;
+    },
+
+    // utils
+    removeComponent(uid) {
+      const { attributes } = state.schema;
+
+      Object.keys(attributes).forEach(key => {
+        const attr = attributes[key];
+
+        if (attr.type === 'component' && attr.component === uid) {
+          this.deleteAttribute(key);
+        }
+
+        if (
+          attr.type === 'dynamiczone' &&
+          Array.isArray(attr.components) &&
+          attr.components.includes(uid)
+        ) {
+          const updatedComponentList = attributes[key].components.filter(val => val !== uid);
+          this.set(['attributes', key, 'components'], updatedComponentList);
+        }
+      });
+
+      return this;
+    },
+
+    updateComponent(uid, newUID) {
+      const { attributes } = state.schema;
+
+      Object.keys(attributes).forEach(key => {
+        const attr = attributes[key];
+
+        if (attr.type === 'component' && attr.component === uid) {
+          this.set(['attributes', key, 'component'], newUID);
+        }
+
+        if (
+          attr.type === 'dynamiczone' &&
+          Array.isArray(attr.components) &&
+          attr.components.includes(uid)
+        ) {
+          const updatedComponentList = attr.components.map(val => (val === uid ? newUID : val));
+
+          this.set(['attributes', key, 'components'], updatedComponentList);
+        }
+      });
+
+      return this;
+    },
+
+    // save the schema to disk
+    async flush() {
+      if (!this.writable) {
+        return;
+      }
+
+      const initialPath = path.join(initialState.dir, initialState.filename);
+      const filePath = path.join(state.dir, state.filename);
+
+      if (deleted === true) {
+        await fse.remove(initialPath);
+
+        const list = await fse.readdir(initialState.dir);
+        if (list.length === 0) {
+          await fse.remove(initialState.dir);
+        }
+
+        return;
+      }
+
+      if (modified === true) {
+        await fse.ensureFile(filePath);
+
+        await fse.writeJSON(
+          filePath,
+          {
+            kind: state.schema.kind,
+            connection: state.schema.connection,
+            collectionName: state.schema.collectionName,
+            info: state.schema.info,
+            options: state.schema.options,
+            pluginOptions: state.schema.pluginOptions,
+            attributes: state.schema.attributes,
+          },
+          { spaces: 2 }
+        );
+
+        // remove from oldPath
+        if (initialPath !== filePath) {
+          await fse.remove(initialPath);
+
+          const list = await fse.readdir(initialState.dir);
+          if (list.length === 0) {
+            await fse.remove(initialState.dir);
+          }
+        }
+
+        return;
+      }
+
+      return Promise.resolve();
+    },
+
+    // reset the schema to its initial value
+    async rollback() {
+      if (!this.writable) {
+        return;
+      }
+
+      const initialPath = path.join(initialState.dir, initialState.filename);
+      const filePath = path.join(state.dir, state.filename);
+
+      // it was a creation so it needs to be deleted
+      if (!initialState.uid) {
+        await fse.remove(filePath);
+
+        const list = await fse.readdir(state.dir);
+        if (list.length === 0) {
+          await fse.remove(state.dir);
+        }
+        return;
+      }
+
+      if (modified === true || deleted === true) {
+        await fse.ensureFile(initialPath);
+        await fse.writeJSON(initialPath, initialState.schema, { spaces: 2 });
+
+        // remove
+        if (initialPath !== filePath) {
+          await fse.remove(filePath);
+
+          const list = await fse.readdir(state.dir);
+          if (list.length === 0) {
+            await fse.remove(state.dir);
+          }
+        }
+      }
+
+      return Promise.resolve();
+    },
+  };
+};

package/utils/attributes.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const _ = require('lodash');
+const utils = require('@akemona-org/strapi-utils');
+const { isMediaAttribute } = require('@akemona-org/strapi-utils').contentTypes;
+
+const toUID = (name, plugin) => {
+  const modelUID = Object.keys(strapi.contentTypes).find((key) => {
+    const ct = strapi.contentTypes[key];
+    if (ct.modelName === name && ct.plugin === plugin) return true;
+  });
+
+  return modelUID;
+};
+
+const fromUID = (uid) => {
+  const contentType = strapi.contentTypes[uid];
+  const { modelName, plugin } = contentType;
+
+  return { modelName, plugin };
+};
+
+const hasComponent = (model) => {
+  const compoKeys = Object.keys(model.attributes || {}).filter((key) => {
+    return model.attributes[key].type === 'component';
+  });
+
+  return compoKeys.length > 0;
+};
+
+const isConfigurable = (attribute) => _.get(attribute, 'configurable', true);
+
+const isRelation = (attribute) =>
+  _.has(attribute, 'target') || _.has(attribute, 'model') || _.has(attribute, 'collection');
+
+/**
+ * Formats a component's attributes
+ * @param {Object} attributes - the attributes map
+ * @param {Object} context - function context
+ * @param {Object} context.component - the associated component
+ */
+const formatAttributes = (model) => {
+  const { getVisibleAttributes } = utils.contentTypes;
+
+  // only get attributes that can be seen in the CTB
+  return getVisibleAttributes(model).reduce((acc, key) => {
+    acc[key] = formatAttribute(key, model.attributes[key], { model });
+    return acc;
+  }, {});
+};
+
+/**
+ * Fromats a component attribute
+ * @param {string} key - the attribute key
+ * @param {Object} attribute - the attribute
+ * @param {Object} context - function context
+ * @param {Object} context.component - the associated component
+ */
+const formatAttribute = (key, attribute, { model }) => {
+  if (_.has(attribute, 'type')) return attribute;
+
+  // format relations
+  const relation = (model.associations || []).find((assoc) => assoc.alias === key);
+  const { plugin, configurable } = attribute;
+  let targetEntity = attribute.model || attribute.collection;
+
+  if (isMediaAttribute(attribute)) {
+    return {
+      type: 'media',
+      multiple: attribute.collection ? true : false,
+      required: attribute.required ? true : false,
+      configurable: configurable === false ? false : undefined,
+      allowedTypes: attribute.allowedTypes,
+      pluginOptions: attribute.pluginOptions,
+    };
+  } else {
+    return {
+      nature: relation.nature,
+      target: targetEntity === '*' ? targetEntity : toUID(targetEntity, plugin),
+      plugin: plugin || undefined,
+      dominant: attribute.dominant ? true : false,
+      targetAttribute: attribute.via || undefined,
+      columnName: attribute.columnName || undefined,
+      configurable: configurable === false ? false : undefined,
+      targetColumnName: _.get(
+        strapi.getModel(targetEntity, plugin),
+        ['attributes', attribute.via, 'columnName'],
+        undefined
+      ),
+      private: attribute.private ? true : false,
+      unique: attribute.unique ? true : false,
+      autoPopulate: attribute.autoPopulate,
+      pluginOptions: attribute.pluginOptions,
+    };
+  }
+};
+
+// TODO: move to schema builder
+const replaceTemporaryUIDs = (uidMap) => (schema) => {
+  return {
+    ...schema,
+    attributes: Object.keys(schema.attributes).reduce((acc, key) => {
+      const attr = schema.attributes[key];
+      if (attr.type === 'component') {
+        if (_.has(uidMap, attr.component)) {
+          acc[key] = {
+            ...attr,
+            component: uidMap[attr.component],
+          };
+
+          return acc;
+        }
+
+        if (!_.has(strapi.components, attr.component)) {
+          throw new Error('component.notFound');
+        }
+      }
+
+      if (
+        attr.type === 'dynamiczone' &&
+        _.intersection(attr.components, Object.keys(uidMap)).length > 0
+      ) {
+        acc[key] = {
+          ...attr,
+          components: attr.components.map((value) => {
+            if (_.has(uidMap, value)) return uidMap[value];
+
+            if (!_.has(strapi.components, value)) {
+              throw new Error('component.notFound');
+            }
+
+            return value;
+          }),
+        };
+
+        return acc;
+      }
+
+      acc[key] = attr;
+      return acc;
+    }, {}),
+  };
+};
+
+module.exports = {
+  fromUID,
+  toUID,
+  hasComponent,
+  isRelation,
+  isConfigurable,
+  replaceTemporaryUIDs,
+  formatAttributes,
+  formatAttribute,
+};

package/utils/helpers.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const escapeNewlines = (content = '', placeholder = '\n') => {
+  return content.replace(/[\r\n]+/g, placeholder);
+};
+
+const deepTrimObject = attribute => {
+  if (Array.isArray(attribute)) {
+    return attribute.map(deepTrimObject);
+  }
+
+  if (typeof attribute === 'object') {
+    return Object.entries(attribute).reduce((acc, [key, value]) => {
+      const trimmedObject = deepTrimObject(value);
+
+      return { ...acc, [key]: trimmedObject };
+    }, {});
+  }
+
+  return typeof attribute === 'string' ? attribute.trim() : attribute;
+};
+
+/**
+ * Converts a name to a slug
+ * @param {string} name a name to convert
+ */
+
+module.exports = {
+  escapeNewlines,
+  deepTrimObject,
+};