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

package/admin/src/utils/formAPI.js

@@ -0,0 +1,112 @@
+import { cloneDeep, get } from 'lodash';
+import * as yup from 'yup';
+
+const formsAPI = {
+  components: {
+    inputs: {},
+    add({ id, component }) {
+      if (!this.inputs[id]) {
+        this.inputs[id] = component;
+      }
+    },
+  },
+  types: {
+    attribute: {
+      // test: {
+      //   validators: [],
+      //   form: {
+      //     advanced: [
+      //       /* cb */
+      //     ],
+      //     base: [
+      //       /* cb */
+      //     ],
+      //   },
+      // },
+    },
+    contentType: {
+      validators: [],
+      form: {
+        advanced: [],
+        base: [],
+      },
+    },
+    component: {
+      validators: [],
+      form: {
+        advanced: [],
+        base: [],
+      },
+    },
+  },
+  contentTypeSchemaMutations: [],
+  addContentTypeSchemaMutation(cb) {
+    this.contentTypeSchemaMutations.push(cb);
+  },
+  extendContentType({ validator, form: { advanced, base } }) {
+    const { contentType } = this.types;
+
+    contentType.validators.push(validator);
+    contentType.form.advanced.push(advanced);
+    contentType.form.base.push(base);
+  },
+  extendFields(fields, { validator, form: { advanced, base } }) {
+    const formType = this.types.attribute;
+
+    fields.forEach(field => {
+      if (!formType[field]) {
+        formType[field] = {
+          validators: [],
+          form: {
+            advanced: [
+              /* cb */
+            ],
+            base: [
+              /* cb */
+            ],
+          },
+        };
+
+        formType[field].validators.push(validator);
+        formType[field].form.advanced.push(advanced);
+        formType[field].form.base.push(base);
+      }
+    });
+  },
+  makeAdvancedForm(target, initSections, props) {
+    const sectionsToAdd = get(this.types, [...target, 'form', 'advanced'], []).reduce(
+      (acc, current) => {
+        const sections = current(props);
+
+        return [...acc, ...sections];
+      },
+      []
+    );
+
+    return { items: [...initSections, ...sectionsToAdd] };
+  },
+  makeValidator(target, initShape, ...args) {
+    const validators = get(this.types, [...target, 'validators'], []);
+
+    const pluginOptionsShape = validators.reduce((acc, current) => {
+      const pluginOptionShape = current(args);
+
+      return { ...acc, ...pluginOptionShape };
+    }, {});
+
+    return initShape.shape({ pluginOptions: yup.object().shape(pluginOptionsShape) });
+  },
+  mutateContentTypeSchema(data, initialData) {
+    let enhancedData = cloneDeep(data);
+
+    const refData = cloneDeep(initialData);
+
+    this.contentTypeSchemaMutations.forEach(cb => {
+      enhancedData = cb(enhancedData, refData);
+    });
+
+    return enhancedData;
+  },
+};
+
+export default formsAPI;

package/admin/src/utils/getAttributeDisplayedType.js

@@ -0,0 +1,31 @@
+const getAttributeDisplayedType = type => {
+  let displayedType;
+
+  switch (type) {
+    case 'date':
+    case 'datetime':
+    case 'time':
+    case 'timestamp':
+      displayedType = 'date';
+      break;
+    case 'integer':
+    case 'biginteger':
+    case 'decimal':
+    case 'float':
+      displayedType = 'number';
+      break;
+    case 'string':
+    case 'text':
+      displayedType = 'text';
+      break;
+    case '':
+      displayedType = 'relation';
+      break;
+    default:
+      displayedType = type;
+  }
+
+  return displayedType;
+};
+
+export default getAttributeDisplayedType;

package/admin/src/utils/getComponents.js

@@ -0,0 +1,31 @@
+import React from 'react';
+import { get } from 'lodash';
+import pluginId from '../pluginId';
+
+/**
+ * Retrieve external links from injected components
+ * @type {Array} List of external links to display
+ */
+const getInjectedComponents = (container, area, plugins, rest) => {
+  const componentsToInject = Object.keys(plugins).reduce((acc, current) => {
+    // Retrieve injected compos from plugin
+    const currentPlugin = plugins[current];
+    const injectedComponents = get(currentPlugin, 'injectedComponents', []);
+
+    const compos = injectedComponents
+      .filter(compo => {
+        return compo.plugin === `${pluginId}.${container}` && compo.area === area;
+      })
+      .map(compo => {
+        const Component = compo.component;
+
+        return <Component {...compo} {...rest} key={compo.key} />;
+      });
+
+    return [...acc, ...compos];
+  }, []);
+
+  return componentsToInject;
+};
+
+export default getInjectedComponents;

package/admin/src/utils/getTrad.js

@@ -0,0 +1,5 @@
+import pluginId from '../pluginId';
+
+const getTrad = id => `${pluginId}.${id}`;
+
+export default getTrad;

package/admin/src/utils/makeSearch.js

@@ -0,0 +1,15 @@
+const makeSearch = (searchObj, shouldContinue = true) => {
+  if (!shouldContinue) {
+    return '';
+  }
+
+  return Object.keys(searchObj).reduce((acc, current, index) => {
+    if (searchObj[current] !== null) {
+      acc = `${acc}${index === 0 ? '' : '&'}${current}=${searchObj[current]}`;
+    }
+
+    return acc;
+  }, '');
+};
+
+export default makeSearch;

package/admin/src/utils/makeUnique.js

@@ -0,0 +1,3 @@
+const makeUnique = array => [...new Set(array)];
+
+export default makeUnique;

package/config/functions/bootstrap.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = async () => {
+  const actions = [
+    {
+      section: 'plugins',
+      displayName: 'Read',
+      uid: 'read',
+      pluginName: 'content-type-builder',
+    },
+  ];
+
+  await strapi.admin.services.permission.actionProvider.registerMany(actions);
+};

package/config/routes.json

@@ -0,0 +1,144 @@
+{
+  "routes": [
+    {
+      "method": "GET",
+      "path": "/reserved-names",
+      "handler": "Builder.getReservedNames",
+      "config": {
+        "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/connections",
+      "handler": "Connections.getConnections",
+      "config": {
+        "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/content-types",
+      "handler": "ContentTypes.getContentTypes",
+      "config": {
+        "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/content-types/:uid",
+      "handler": "ContentTypes.getContentType",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/content-types",
+      "handler": "ContentTypes.createContentType",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/content-types/:uid",
+      "handler": "ContentTypes.updateContentType",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/content-types/:uid",
+      "handler": "ContentTypes.deleteContentType",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/components",
+      "handler": "Components.getComponents",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/components/:uid",
+      "handler": "Components.getComponent",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/components",
+      "handler": "Components.createComponent",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/components/:uid",
+      "handler": "Components.updateComponent",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/components/:uid",
+      "handler": "Components.deleteComponent",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/component-categories/:name",
+      "handler": "ComponentCategories.editCategory",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/component-categories/:name",
+      "handler": "ComponentCategories.deleteCategory",
+      "config": {
+      "policies": [
+          ["admin::hasPermissions", ["plugins::content-type-builder.read"]]
+        ]
+      }
+    }
+  ]
+}

package/controllers/Builder.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  getReservedNames(ctx) {
+    ctx.body = strapi.plugins['content-type-builder'].services.builder.getReservedNames();
+  },
+};

package/controllers/ComponentCategories.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const validateComponentCategory = require('./validation/component-category');
+
+module.exports = {
+  async editCategory(ctx) {
+    const { body } = ctx.request;
+
+    try {
+      await validateComponentCategory(body);
+    } catch (error) {
+      return ctx.send({ error }, 400);
+    }
+
+    const { name } = ctx.params;
+
+    strapi.reload.isWatching = false;
+
+    const componentCategoryService =
+      strapi.plugins['content-type-builder'].services.componentcategories;
+
+    const newName = await componentCategoryService.editCategory(name, body);
+
+    setImmediate(() => strapi.reload());
+
+    ctx.send({ name: newName });
+  },
+
+  async deleteCategory(ctx) {
+    const { name } = ctx.params;
+
+    strapi.reload.isWatching = false;
+
+    const componentCategoryService =
+      strapi.plugins['content-type-builder'].services.componentcategories;
+
+    await componentCategoryService.deleteCategory(name);
+
+    setImmediate(() => strapi.reload());
+
+    ctx.send({ name });
+  },
+};

package/controllers/Components.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const _ = require('lodash');
+
+const {
+  validateComponentInput,
+  validateUpdateComponentInput,
+} = require('./validation/component');
+
+/**
+ * Components controller
+ */
+
+module.exports = {
+  /**
+   * GET /components handler
+   * Returns a list of available components
+   * @param {Object} ctx - koa context
+   */
+  async getComponents(ctx) {
+    const componentService =
+      strapi.plugins['content-type-builder'].services.components;
+
+    const data = Object.keys(strapi.components).map(uid => {
+      return componentService.formatComponent(strapi.components[uid]);
+    });
+
+    ctx.send({ data });
+  },
+
+  /**
+   * GET /components/:uid
+   * Returns a specific component
+   * @param {Object} ctx - koa context
+   */
+  async getComponent(ctx) {
+    const { uid } = ctx.params;
+
+    const component = strapi.components[uid];
+
+    if (!component) {
+      return ctx.send({ error: 'component.notFound' }, 404);
+    }
+
+    const componentService =
+      strapi.plugins['content-type-builder'].services.components;
+
+    ctx.send({ data: componentService.formatComponent(component) });
+  },
+
+  /**
+   * POST /components
+   * Creates a component and returns its infos
+   * @param {Object} ctx - koa context
+   */
+  async createComponent(ctx) {
+    const { body } = ctx.request;
+
+    try {
+      await validateComponentInput(body);
+    } catch (error) {
+      return ctx.send({ error }, 400);
+    }
+
+    try {
+      strapi.reload.isWatching = false;
+
+      const componentService =
+        strapi.plugins['content-type-builder'].services.components;
+
+      const component = await componentService.createComponent({
+        component: body.component,
+        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);
+    }
+  },
+
+  /**
+   * PUT /components/:uid
+   * Updates a component and return its infos
+   * @param {Object} ctx - koa context - enhanced koa context
+   */
+  async updateComponent(ctx) {
+    const { uid } = ctx.params;
+    const { body } = ctx.request;
+
+    if (!_.has(strapi.components, uid)) {
+      return ctx.send({ error: 'component.notFound' }, 404);
+    }
+
+    try {
+      await validateUpdateComponentInput(body);
+    } catch (error) {
+      return ctx.send({ error }, 400);
+    }
+
+    try {
+      strapi.reload.isWatching = false;
+
+      const componentService =
+        strapi.plugins['content-type-builder'].services.components;
+
+      const component = await componentService.editComponent(uid, {
+        component: body.component,
+        components: body.components,
+      });
+
+      setImmediate(() => strapi.reload());
+
+      ctx.send({ data: { uid: component.uid } });
+    } catch (error) {
+      strapi.log.error(error);
+      ctx.send({ error: error.message }, 400);
+    }
+  },
+
+  /**
+   * DELETE /components/:uid
+   * Deletes a components and returns its old infos
+   * @param {Object} ctx - koa context
+   */
+  async deleteComponent(ctx) {
+    const { uid } = ctx.params;
+
+    if (!_.has(strapi.components, uid)) {
+      return ctx.send({ error: 'component.notFound' }, 404);
+    }
+
+    try {
+      strapi.reload.isWatching = false;
+
+      const componentService =
+        strapi.plugins['content-type-builder'].services.components;
+
+      const component = await componentService.deleteComponent(uid);
+
+      setImmediate(() => strapi.reload());
+
+      ctx.send({ data: { uid: component.uid } });
+    } catch (error) {
+      strapi.log.error(error);
+      ctx.send({ error: error.message }, 400);
+    }
+  },
+};

package/controllers/Connections.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = {
+  async getConnections(ctx) {
+    ctx.send({
+      connections: Object.keys(strapi.config.get('database.connections')),
+    });
+  },
+};