@akemona-org/strapi-plugin-content-manager 3.7.0

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@akemona-org/strapi-plugin-content-manager",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "3.7.0",
+  "description": "A powerful UI to easily manage your data.",
+  "strapi": {
+    "name": "Content Manager",
+    "icon": "plug",
+    "description": "content-manager.plugin.description",
+    "required": true
+  },
+  "dependencies": {
+    "@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",
+    "classnames": "^2.3.1",
+    "codemirror": "^5.61.0",
+    "draft-js": "^0.11.5",
+    "highlight.js": "^10.4.1",
+    "immutable": "^3.8.2",
+    "lodash": "4.17.21",
+    "markdown-it": "^12.0.6",
+    "markdown-it-abbr": "^1.0.4",
+    "markdown-it-container": "^3.0.0",
+    "markdown-it-deflist": "^2.0.3",
+    "markdown-it-emoji": "^2.0.0",
+    "markdown-it-footnote": "^3.0.2",
+    "markdown-it-ins": "^3.0.1",
+    "markdown-it-mark": "^3.0.1",
+    "markdown-it-sub": "^1.0.0",
+    "markdown-it-sup": "^1.0.0",
+    "pluralize": "^8.0.0",
+    "react": "^16.14.0",
+    "react-dom": "^16.9.0",
+    "react-fast-compare": "^3.2.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",
+    "sanitize-html": "2.7.2",
+    "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/components.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const { has, isNil, mapValues } = require('lodash/fp');
+
+const { getService } = require('../utils');
+const storeUtils = require('./utils/store');
+const createConfigurationService = require('./configuration');
+
+const STORE_KEY_PREFIX = 'components';
+
+const configurationService = createConfigurationService({
+  storeUtils,
+  isComponent: true,
+  prefix: STORE_KEY_PREFIX,
+  getModels() {
+    const { toContentManagerModel } = getService('data-mapper');
+
+    return mapValues(toContentManagerModel, strapi.components);
+  },
+});
+
+module.exports = {
+  findAllComponents() {
+    const { toContentManagerModel } = getService('data-mapper');
+
+    return Object.values(strapi.components).map(toContentManagerModel);
+  },
+
+  findComponent(uid) {
+    const { toContentManagerModel } = getService('data-mapper');
+
+    const component = strapi.components[uid];
+
+    return isNil(component) ? component : toContentManagerModel(component);
+  },
+
+  // configuration
+
+  async findConfiguration(component) {
+    const configuration = await configurationService.getConfiguration(component.uid);
+
+    return {
+      uid: component.uid,
+      category: component.categoru,
+      ...configuration,
+    };
+  },
+
+  async updateConfiguration(component, newConfiguration) {
+    await configurationService.setConfiguration(component.uid, newConfiguration);
+
+    return this.findConfiguration(component);
+  },
+
+  async findComponentsConfigurations(model) {
+    const componentsMap = {};
+
+    const getComponentConfigurations = async uid => {
+      const component = this.findComponent(uid);
+
+      if (has(uid, componentsMap)) return;
+
+      const componentConfiguration = await this.findConfiguration(component);
+      const componentsConfigurations = await this.findComponentsConfigurations(component);
+
+      Object.assign(componentsMap, {
+        [uid]: componentConfiguration,
+        ...componentsConfigurations,
+      });
+    };
+
+    for (const key in model.attributes) {
+      const attribute = model.attributes[key];
+
+      if (attribute.type === 'component') {
+        await getComponentConfigurations(attribute.component);
+      }
+
+      if (attribute.type === 'dynamiczone') {
+        for (const componentUid of attribute.components) {
+          await getComponentConfigurations(componentUid);
+        }
+      }
+    }
+
+    return componentsMap;
+  },
+
+  syncConfigurations() {
+    return configurationService.syncConfigurations();
+  },
+};

package/services/configuration.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const { intersection, difference } = require('lodash');
+const { createDefaultConfiguration, syncConfiguration } = require('./utils/configuration');
+
+module.exports = ({ isComponent, prefix, storeUtils, getModels }) => {
+  const uidToStoreKey = uid => {
+    return `${prefix}::${uid}`;
+  };
+
+  const getConfiguration = uid => {
+    const storeKey = uidToStoreKey(uid);
+    return storeUtils.getModelConfiguration(storeKey);
+  };
+
+  const setConfiguration = (uid, input) => {
+    const { settings, metadatas, layouts } = input;
+
+    const configuration = {
+      uid,
+      settings,
+      metadatas,
+      layouts,
+    };
+
+    if (isComponent) {
+      configuration.isComponent = isComponent;
+    }
+
+    const storeKey = uidToStoreKey(uid);
+    return storeUtils.setModelConfiguration(storeKey, configuration);
+  };
+
+  const deleteConfiguration = uid => {
+    const storeKey = uidToStoreKey(uid);
+    return storeUtils.deleteKey(storeKey);
+  };
+
+  const syncConfigurations = async () => {
+    const models = getModels();
+
+    const configurations = await storeUtils.findByKey(
+      `plugin_content_manager_configuration_${prefix}`
+    );
+
+    const updateConfiguration = async uid => {
+      const conf = configurations.find(conf => conf.uid === uid);
+
+      return setConfiguration(uid, await syncConfiguration(conf, models[uid]));
+    };
+
+    const generateNewConfiguration = async uid => {
+      return setConfiguration(uid, await createDefaultConfiguration(models[uid]));
+    };
+
+    const currentUIDS = Object.keys(models);
+    const DBUIDs = configurations.map(({ uid }) => uid);
+
+    const contentTypesToUpdate = intersection(currentUIDS, DBUIDs);
+    const contentTypesToAdd = difference(currentUIDS, DBUIDs);
+    const contentTypesToDelete = difference(DBUIDs, currentUIDS);
+
+    // delete old schemas
+    await Promise.all(contentTypesToDelete.map(uid => deleteConfiguration(uid)));
+
+    // create new schemas
+    await Promise.all(contentTypesToAdd.map(uid => generateNewConfiguration(uid)));
+
+    // update current schemas
+    await Promise.all(contentTypesToUpdate.map(uid => updateConfiguration(uid)));
+  };
+
+  return {
+    getConfiguration,
+    setConfiguration,
+    deleteConfiguration,
+    syncConfigurations,
+  };
+};

package/services/content-types.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const { isNil, mapValues } = require('lodash/fp');
+const { contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+
+const { getService } = require('../utils');
+const storeUtils = require('./utils/store');
+const createConfigurationService = require('./configuration');
+
+const configurationService = createConfigurationService({
+  storeUtils,
+  prefix: 'content_types',
+  getModels() {
+    const { toContentManagerModel } = getService('data-mapper');
+
+    return mapValues(toContentManagerModel, strapi.contentTypes);
+  },
+});
+
+const service = {
+  findAllContentTypes() {
+    const { toContentManagerModel } = getService('data-mapper');
+
+    return Object.values(strapi.contentTypes).map(toContentManagerModel);
+  },
+
+  findContentType(uid) {
+    const { toContentManagerModel } = getService('data-mapper');
+
+    const contentType = strapi.contentTypes[uid];
+
+    return isNil(contentType) ? contentType : toContentManagerModel(contentType);
+  },
+
+  findDisplayedContentTypes() {
+    return this.findAllContentTypes().filter(({ isDisplayed }) => isDisplayed === true);
+  },
+
+  findContentTypesByKind(kind) {
+    if (!kind) {
+      return this.findAllContentTypes();
+    }
+
+    return this.findAllContentTypes().filter(contentTypesUtils.isKind(kind));
+  },
+
+  // configuration
+
+  async findConfiguration(contentType) {
+    const configuration = await configurationService.getConfiguration(contentType.uid);
+
+    return {
+      uid: contentType.uid,
+      ...configuration,
+    };
+  },
+
+  async updateConfiguration(contentType, newConfiguration) {
+    await configurationService.setConfiguration(contentType.uid, newConfiguration);
+    return this.findConfiguration(contentType);
+  },
+
+  findComponentsConfigurations(contentType) {
+    // delegate to componentService
+    return getService('components').findComponentsConfigurations(contentType);
+  },
+
+  syncConfigurations() {
+    return configurationService.syncConfigurations();
+  },
+};
+
+module.exports = service;

package/services/data-mapper.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const { upperFirst, has, prop, pick, getOr } = require('lodash/fp');
+const pluralize = require('pluralize');
+const { contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+const { isMediaAttribute } = require('@akemona-org/strapi-utils').contentTypes;
+
+const dtoFields = [
+  'uid',
+  'isDisplayed',
+  'apiID',
+  'kind',
+  'category',
+  'info',
+  'options',
+  'pluginOptions',
+  'attributes',
+  'pluginOptions',
+];
+
+module.exports = {
+  toContentManagerModel(contentType) {
+    return {
+      ...contentType,
+      apiID: contentType.modelName,
+      isDisplayed: isVisible(contentType),
+      info: {
+        ...contentType.info,
+        label: formatContentTypeLabel(contentType),
+      },
+      attributes: {
+        id: {
+          type: contentType.primaryKeyType,
+        },
+        ...formatAttributes(contentType),
+        ...contentTypesUtils.getTimestampsAttributes(contentType),
+      },
+    };
+  },
+
+  toDto: pick(dtoFields),
+};
+
+const formatContentTypeLabel = (contentType) => {
+  const name = prop('info.name', contentType) || contentType.modelName;
+
+  try {
+    return contentTypesUtils.isSingleType(contentType)
+      ? upperFirst(name)
+      : upperFirst(pluralize(name));
+  } catch (error) {
+    // in case pluralize throws cyrillic characters
+    return upperFirst(name);
+  }
+};
+
+const formatAttributes = (model) => {
+  const { getVisibleAttributes } = contentTypesUtils;
+
+  // only get attributes that can be seen in the auto generated Edit view or List view
+  return getVisibleAttributes(model).reduce((acc, key) => {
+    acc[key] = formatAttribute(key, model.attributes[key], { model });
+    return acc;
+  }, {});
+};
+
+const formatAttribute = (key, attribute, { model }) => {
+  if (has('type', attribute)) return attribute;
+
+  if (isMediaAttribute(attribute)) {
+    return toMedia(attribute);
+  }
+
+  const relation = (model.associations || []).find((assoc) => assoc.alias === key);
+  return toRelation(attribute, relation);
+};
+
+const toMedia = (attribute) => {
+  return {
+    type: 'media',
+    multiple: attribute.collection ? true : false,
+    required: attribute.required ? true : false,
+    allowedTypes: attribute.allowedTypes,
+    pluginOptions: attribute.pluginOptions,
+  };
+};
+
+const toRelation = (attribute, relation) => {
+  return {
+    ...attribute,
+    type: 'relation',
+    targetModel: relation.targetUid,
+    relationType: relation.nature,
+    pluginOptions: attribute.pluginOptions,
+  };
+};
+
+const isVisible = (model) => getOr(true, 'pluginOptions.content-manager.visible', model) === true;

package/services/entity-manager.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const { assoc, has, prop, omit } = require('lodash/fp');
+const strapiUtils = require('@akemona-org/strapi-utils');
+
+const { sanitizeEntity } = strapiUtils;
+const { hasDraftAndPublish } = strapiUtils.contentTypes;
+const { PUBLISHED_AT_ATTRIBUTE, CREATED_BY_ATTRIBUTE } = strapiUtils.contentTypes.constants;
+const { ENTRY_PUBLISH, ENTRY_UNPUBLISH } = strapiUtils.webhook.webhookEvents;
+
+const omitPublishedAtField = omit(PUBLISHED_AT_ATTRIBUTE);
+
+const emitEvent = (event, fn) => async (entity, model) => {
+  const result = await fn(entity, model);
+
+  const modelDef = strapi.getModel(model);
+
+  strapi.eventHub.emit(event, {
+    model: modelDef.modelName,
+    entry: sanitizeEntity(result, { model: modelDef }),
+  });
+
+  return result;
+};
+
+const findCreatorRoles = (entity) => {
+  const createdByPath = `${CREATED_BY_ATTRIBUTE}.id`;
+
+  if (has(createdByPath, entity)) {
+    const creatorId = prop(createdByPath, entity);
+    return strapi.query('role', 'admin').find({ 'users.id': creatorId }, []);
+  }
+
+  return [];
+};
+
+module.exports = {
+  async assocCreatorRoles(entity) {
+    if (!entity) {
+      return entity;
+    }
+
+    const roles = await findCreatorRoles(entity);
+    return assoc(`${CREATED_BY_ATTRIBUTE}.roles`, roles, entity);
+  },
+
+  find(params, model, populate) {
+    return strapi.entityService.find({ params, populate }, { model });
+  },
+
+  findPage(params, model, populate) {
+    return strapi.entityService.findPage({ params, populate }, { model });
+  },
+
+  findWithRelationCounts(params, model, populate) {
+    return strapi.entityService.findWithRelationCounts({ params, populate }, { model });
+  },
+
+  search(params, model, populate) {
+    return strapi.entityService.search({ params, populate }, { model });
+  },
+
+  searchPage(params, model, populate) {
+    return strapi.entityService.searchPage({ params, populate }, { model });
+  },
+
+  searchWithRelationCounts(params, model, populate) {
+    return strapi.entityService.searchWithRelationCounts({ params, populate }, { model });
+  },
+
+  count(params, model) {
+    return strapi.entityService.count({ params }, { model });
+  },
+
+  async findOne(id, model, populate) {
+    return strapi.entityService.findOne({ params: { id }, populate }, { model });
+  },
+
+  async findOneWithCreatorRoles(id, model, populate) {
+    const entity = await this.findOne(id, model, populate);
+
+    if (!entity) {
+      return entity;
+    }
+
+    return this.assocCreatorRoles(entity);
+  },
+
+  async create(body, model) {
+    const modelDef = strapi.getModel(model);
+    const publishData = { ...body };
+
+    if (hasDraftAndPublish(modelDef)) {
+      publishData[PUBLISHED_AT_ATTRIBUTE] = null;
+    }
+
+    return strapi.entityService.create({ data: publishData }, { model });
+  },
+
+  update(entity, body, model) {
+    const params = { id: entity.id };
+    const publishData = omitPublishedAtField(body);
+
+    return strapi.entityService.update({ params, data: publishData }, { model });
+  },
+
+  delete(entity, model) {
+    const params = { id: entity.id };
+    return strapi.entityService.delete({ params }, { model });
+  },
+
+  findAndDelete(params, model) {
+    return strapi.entityService.delete({ params }, { model });
+  },
+
+  publish: emitEvent(ENTRY_PUBLISH, async (entity, model) => {
+    if (entity[PUBLISHED_AT_ATTRIBUTE]) {
+      throw strapi.errors.badRequest('already.published');
+    }
+
+    // validate the entity is valid for publication
+    await strapi.entityValidator.validateEntityCreation(strapi.getModel(model), entity);
+
+    const params = { id: entity.id };
+    const data = { [PUBLISHED_AT_ATTRIBUTE]: new Date() };
+
+    return strapi.entityService.update({ params, data }, { model });
+  }),
+
+  unpublish: emitEvent(ENTRY_UNPUBLISH, (entity, model) => {
+    if (!entity[PUBLISHED_AT_ATTRIBUTE]) {
+      throw strapi.errors.badRequest('already.draft');
+    }
+
+    const params = { id: entity.id };
+    const data = { [PUBLISHED_AT_ATTRIBUTE]: null };
+
+    return strapi.entityService.update({ params, data }, { model });
+  }),
+};

package/services/metrics.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { intersection, prop } = require('lodash/fp');
+const { getRelationalFields } = require('@akemona-org/strapi-utils').relations;
+
+const sendDidConfigureListView = async (contentType, configuration) => {
+  const displayedFields = prop('length', configuration.layouts.list);
+  const relationalFields = getRelationalFields(contentType);
+  const displayedRelationalFields = intersection(
+    relationalFields,
+    configuration.layouts.list
+  ).length;
+
+  const data = {
+    containsRelationalFields: !!displayedRelationalFields,
+  };
+
+  if (data.containsRelationalFields) {
+    Object.assign(data, {
+      displayedFields,
+      displayedRelationalFields,
+    });
+  }
+
+  try {
+    // await strapi.telemetry.send('didConfigureListView', data);
+  } catch (e) {
+    // silence
+  }
+};
+
+module.exports = {
+  sendDidConfigureListView,
+};

package/services/permission-checker.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const ACTIONS = {
+  read: 'plugins::content-manager.explorer.read',
+  create: 'plugins::content-manager.explorer.create',
+  update: 'plugins::content-manager.explorer.update',
+  delete: 'plugins::content-manager.explorer.delete',
+  publish: 'plugins::content-manager.explorer.publish',
+  unpublish: 'plugins::content-manager.explorer.publish',
+};
+
+const createPermissionChecker = ({ userAbility, model }) => {
+  const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
+    ability: userAbility,
+    model,
+  });
+
+  const toSubject = entity => (entity ? permissionsManager.toSubject(entity, model) : model);
+
+  const can = (action, entity, field) => {
+    return userAbility.can(action, toSubject(entity), field);
+  };
+
+  const cannot = (action, entity, field) => {
+    return userAbility.cannot(action, toSubject(entity), field);
+  };
+
+  const sanitizeOutput = (data, { action = ACTIONS.read } = {}) => {
+    return permissionsManager.sanitize(data, {
+      subject: toSubject(data),
+      action,
+    });
+  };
+
+  const sanitizeInput = (action, data, entity) => {
+    return permissionsManager.sanitize(data, {
+      subject: entity ? toSubject(entity) : model,
+      action,
+      isOutput: false,
+    });
+  };
+
+  const sanitizeCreateInput = data => sanitizeInput(ACTIONS.create, data);
+  const sanitizeUpdateInput = entity => data => sanitizeInput(ACTIONS.update, data, entity);
+
+  const buildPermissionQuery = (query, action) => permissionsManager.queryFrom(query, action);
+
+  const buildReadQuery = query => buildPermissionQuery(query, ACTIONS.read);
+  const buildDeleteQuery = query => buildPermissionQuery(query, ACTIONS.delete);
+
+  Object.keys(ACTIONS).forEach(action => {
+    can[action] = (...args) => can(ACTIONS[action], ...args);
+    cannot[action] = (...args) => cannot(ACTIONS[action], ...args);
+  });
+
+  return {
+    can,
+    cannot,
+    sanitizeOutput,
+    sanitizeCreateInput,
+    sanitizeUpdateInput,
+    buildReadQuery,
+    buildDeleteQuery,
+  };
+};
+
+module.exports = {
+  create: createPermissionChecker,
+};