@akemona-org/strapi-admin 3.7.0

package/services/permission/sections-builder/builder.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const createSection = require('./section');
+
+/**
+ * Create a new section builder with its own sections registry
+ */
+const createSectionBuilder = () => {
+  const state = {
+    sections: new Map(),
+  };
+
+  return {
+    /**
+     * Create & add a section to the builder's registry
+     * @param {string} sectionName - The unique name of the section
+     * @param {SectionOptions} options - The options used to build a {@link Section}
+     * @return {this}
+     */
+    createSection(sectionName, options) {
+      const section = createSection(options);
+
+      state.sections.set(sectionName, section);
+
+      return this;
+    },
+
+    /**
+     * Removes a section from the builder's registry using its unique name
+     * @param {string} sectionName - The name of the section to delete
+     * @return {this}
+     */
+    deleteSection(sectionName) {
+      state.sections.remove(sectionName);
+
+      return this;
+    },
+
+    /**
+     * Register a handler function for a given section
+     * @param {string} sectionName - The name of the section
+     * @param {Function} handler - The handler to register
+     * @return {this}
+     */
+    addHandler(sectionName, handler) {
+      if (state.sections.has(sectionName)) {
+        state.sections.get(sectionName).hooks.handlers.register(handler);
+      }
+
+      return this;
+    },
+
+    /**
+     * Register a matcher function for a given section
+     * @param {string} sectionName - The name of the section
+     * @param {Function} matcher - The handler to register
+     * @return {this}
+     */
+    addMatcher(sectionName, matcher) {
+      if (state.sections.has(sectionName)) {
+        state.sections.get(sectionName).hooks.matchers.register(matcher);
+      }
+
+      return this;
+    },
+
+    /**
+     * Build a section tree based on the registered actions and the given actions
+     * @param {Array<Action>} actions - The actions used to build each section
+     * @return {Promise<any>}
+     */
+    async build(actions = []) {
+      const sections = {};
+
+      for (const [sectionName, section] of state.sections.entries()) {
+        sections[sectionName] = await section.build(actions);
+      }
+
+      return sections;
+    },
+  };
+};
+
+module.exports = createSectionBuilder;

package/services/permission/sections-builder/handlers.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const { isVisibleAttribute } = require('@akemona-org/strapi-utils').contentTypes;
+
+const {
+  toSubjectTemplate,
+  getValidOptions,
+  hasProperty,
+  isNotInSubjects,
+  resolveContentType,
+  isOfKind,
+} = require('./utils');
+
+/**
+ * @typedef ContentTypesSection
+ * @property {Array<Action>} actions
+ * @property {Array<Object>} subjects
+ */
+
+/**
+ * @typedef {Array<Action>} ActionArraySection
+ */
+
+/**
+ * Transforms & adds the given  setting action to the section
+ * Note: The action is transformed to a setting specific format
+ * @param {object} options
+ * @param {Action} options.action
+ * @param {ActionArraySection} section
+ */
+const settings = ({ action, section }) => {
+  const { category, subCategory, displayName, actionId } = action;
+
+  section.push({
+    displayName,
+    category,
+    subCategory,
+    action: actionId,
+  });
+};
+
+/**
+ * Transforms & adds the given plugin action to the section
+ * Note: The action is transformed to a plugin specific format
+ * @param {object} options
+ * @param {Action} options.action
+ * @param {ActionArraySection} section
+ */
+const plugins = ({ action, section }) => {
+  const { pluginName, subCategory, displayName, actionId } = action;
+
+  section.push({
+    displayName,
+    plugin: pluginName,
+    subCategory,
+    action: actionId,
+  });
+};
+
+/**
+ * Transforms & adds the given action to the section's actions field
+ * Note: The action is transformed to a content-type specific format
+ * @param {object} options
+ * @param {Action} options.action
+ * @param {ContentTypesSection} section
+ */
+const contentTypesBase = ({ action, section }) => {
+  const { displayName, actionId, subjects, options } = action;
+
+  section.actions.push({
+    label: displayName,
+    actionId,
+    subjects,
+    ...getValidOptions(options),
+  });
+};
+
+/**
+ * Initialize the subjects array of a section based on the action's subjects
+ */
+const subjectsHandlerFor =
+  (kind) =>
+  ({ action, section: contentTypesSection }) => {
+    const { subjects } = action;
+
+    const newSubjects = subjects
+      // Ignore already added subjects
+      .filter(isNotInSubjects(contentTypesSection.subjects))
+      // Transform UIDs into content-types
+      .map(resolveContentType)
+      // Only keep specific kind of content-types
+      .filter(isOfKind(kind))
+      // Transform the content-types into section's subjects
+      .map(toSubjectTemplate);
+
+    contentTypesSection.subjects.push(...newSubjects);
+  };
+
+const buildNode = (model, attributeName, attribute) => {
+  if (!isVisibleAttribute(model, attributeName)) {
+    return null;
+  }
+
+  const node = { label: attributeName, value: attributeName };
+
+  if (attribute.required) {
+    Object.assign(node, { required: true });
+  }
+
+  if (attribute.type === 'component') {
+    const component = strapi.components[attribute.component];
+    return { ...node, children: buildDeepAttributesCollection(component) };
+  }
+
+  return node;
+};
+
+const buildDeepAttributesCollection = (model) => {
+  return Object.entries(model.attributes)
+    .map(([attributeName, attribute]) => buildNode(model, attributeName, attribute))
+    .filter((node) => node !== null);
+};
+
+/**
+ * Create and populate the fields property for section's subjects based on the action's subjects list
+ * @param {object} options
+ * @param {Action} options.action
+ * @param {ContentTypesSection} section
+ */
+const fieldsProperty = ({ action, section }) => {
+  const { subjects } = action;
+
+  section.subjects
+    .filter((subject) => subjects.includes(subject.uid))
+    .forEach((subject) => {
+      const { uid } = subject;
+      const contentType = resolveContentType(uid);
+
+      if (hasProperty('fields', subject)) {
+        return;
+      }
+
+      const fields = buildDeepAttributesCollection(contentType);
+      const fieldsProp = { label: 'Fields', value: 'fields', children: fields };
+
+      subject.properties.push(fieldsProp);
+    });
+};
+
+module.exports = {
+  plugins,
+  settings,
+  subjectsHandlerFor,
+  contentTypesBase,
+  fieldsProperty,
+};

package/services/permission/sections-builder/index.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { propEq } = require('lodash/fp');
+const createSectionBuilder = require('./builder');
+const {
+  subjectsHandlerFor,
+  contentTypesBase,
+  fieldsProperty,
+  plugins: pluginsHandler,
+  settings: settingsHandler,
+} = require('./handlers');
+
+const sectionPropMatcher = propEq('section');
+
+const createContentTypesInitialState = () => ({
+  actions: [],
+  subjects: [],
+});
+
+const createDefaultSectionBuilder = () => {
+  const builder = createSectionBuilder();
+
+  builder.createSection('plugins', {
+    initialStateFactory: () => [],
+    handlers: [pluginsHandler],
+    matchers: [sectionPropMatcher('plugins')],
+  });
+
+  builder.createSection('settings', {
+    initialStateFactory: () => [],
+    handlers: [settingsHandler],
+    matchers: [sectionPropMatcher('settings')],
+  });
+
+  builder.createSection('singleTypes', {
+    initialStateFactory: createContentTypesInitialState,
+    handlers: [contentTypesBase, subjectsHandlerFor('singleType'), fieldsProperty],
+    matchers: [sectionPropMatcher('contentTypes')],
+  });
+
+  builder.createSection('collectionTypes', {
+    initialStateFactory: createContentTypesInitialState,
+    handlers: [contentTypesBase, subjectsHandlerFor('collectionType'), fieldsProperty],
+    matchers: [sectionPropMatcher('contentTypes')],
+  });
+
+  return builder;
+};
+
+module.exports = createDefaultSectionBuilder;

package/services/permission/sections-builder/section.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { eq } = require('lodash/fp');
+const { hooks } = require('@akemona-org/strapi-utils');
+
+/**
+ * @typedef SectionOptions
+ * @property {function():any} initialStateFactory - A factory function that returns the default shape of the section
+ * @property {Array<Function>} handlers - An initial collection of handlers which will be registered in the handlers hook
+ * @property {Array<Function>} matchers - An initial collection of matchers which will be registered in the matchers hook
+ */
+
+const emptyObjectFactory = () => ({});
+
+/**
+ * Upon call, creates a new section object
+ * @param {SectionOptions} options
+ */
+const createSection = ({
+  initialStateFactory = emptyObjectFactory,
+  handlers = [],
+  matchers = [],
+} = {}) => {
+  const state = {
+    hooks: {
+      handlers: hooks.createAsyncSeriesHook(),
+      matchers: hooks.createAsyncParallelHook(),
+    },
+  };
+
+  // Register initial hooks
+  handlers.forEach((handler) => state.hooks.handlers.register(handler));
+  matchers.forEach((matcher) => state.hooks.matchers.register(matcher));
+
+  return {
+    hooks: state.hooks,
+
+    /**
+     * Verifies if an action can be applied to the section by running the matchers hook.
+     * If any of the registered matcher functions returns true, then the condition applies.
+     * @param {Action} action
+     * @return {Promise<boolean>}
+     */
+    async appliesToAction(action) {
+      const results = await state.hooks.matchers.call(action);
+
+      return results.some(eq(true));
+    },
+
+    /**
+     * Init, build and returns a section object based on the given actions
+     * @param {Array<Action>} actions - A list of actions used to populate the section
+     * @return {Promise<any>}
+     */
+    async build(actions = []) {
+      const section = initialStateFactory();
+
+      for (const action of actions) {
+        const applies = await this.appliesToAction(action);
+
+        if (applies) {
+          await state.hooks.handlers.call({ action, section });
+        }
+      }
+
+      return section;
+    },
+  };
+};
+
+module.exports = createSection;

package/services/permission/sections-builder/utils.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { curry, matchesProperty, pick } = require('lodash/fp');
+
+const isOfKind = kind => matchesProperty('kind', kind);
+
+const resolveContentType = uid => strapi.contentTypes[uid];
+
+const isNotInSubjects = subjects => uid => !subjects.find(subject => subject.uid === uid);
+
+const hasProperty = curry((property, subject) => {
+  return !!subject.properties.find(prop => prop.value === property);
+});
+
+const getValidOptions = pick(['applyToProperties']);
+
+const toSubjectTemplate = ct => ({ uid: ct.uid, label: ct.info.name, properties: [] });
+
+module.exports = {
+  isOfKind,
+  resolveContentType,
+  isNotInSubjects,
+  hasProperty,
+  getValidOptions,
+  toSubjectTemplate,
+};

package/services/permission.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const domain = require('../domain/permission');
+const createActionProvider = require('../domain/action/provider');
+const createConditionProvider = require('../domain/condition/provider');
+const createPermissionsManager = require('./permission/permissions-manager');
+const createPermissionEngine = require('./permission/engine');
+const createSectionsBuilder = require('./permission/sections-builder');
+const permissionQueries = require('./permission/queries');
+
+const actionProvider = createActionProvider();
+const conditionProvider = createConditionProvider();
+const engine = createPermissionEngine(conditionProvider);
+const sectionsBuilder = createSectionsBuilder();
+
+const sanitizePermission = domain.sanitizePermissionFields;
+
+module.exports = {
+  // Queries / Actions
+  ...permissionQueries,
+  // Utils
+  createPermissionsManager,
+  sectionsBuilder,
+  sanitizePermission,
+  // Engine
+  engine,
+  // Providers
+  actionProvider,
+  conditionProvider,
+};