@akemona-org/strapi-admin 3.7.0

package/domain/action/index.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const { curry, pipe, merge, set, pick, omit, includes, isArray, prop } = require('lodash/fp');
+
+/**
+ * Domain representation of an Action (RBAC)
+ * @typedef {Object} Action
+ * @property {string} actionId - The unique identifier of the action
+ * @property {string} section - The section linked to the action
+ * @property {string} displayName - The human readable name of an action
+ * @property {string} category - The main category of an action
+ * @property {string} [subCategory] - The secondary category of an action (only for settings and plugins section)
+ * @property {string} [pluginName] - The plugin which provide the action
+ * @property {string[]} [subjects] - A list of subjects on which the action can be applied
+ * @property {Object} options - The options of an action
+ * @property {string[]} options.applyToProperties - The list of properties that can be associated with an action
+ */
+
+/**
+ * Set of attributes used to create a new {@link Action} object
+ * @typedef {Action, { uid: string }} CreateActionPayload
+ */
+
+/**
+ * Return the default attributes of a new {@link Action}
+ * @return Partial<Action>
+ */
+const getDefaultActionAttributes = () => ({
+  options: {
+    applyToProperties: null,
+  },
+});
+
+/**
+ * Get the list of all the valid attributes of an {@link Action}
+ * @return {string[]}
+ */
+const actionFields = [
+  'section',
+  'displayName',
+  'category',
+  'subCategory',
+  'pluginName',
+  'subjects',
+  'options',
+  'actionId',
+];
+
+/**
+ * Remove unwanted attributes from an {@link Action}
+ * @type {function(action: Action | CreateActionPayload): Action}
+ */
+const sanitizeActionAttributes = pick(actionFields);
+
+/**
+ * Create and return an identifier for an {@link CreateActionPayload}.
+ * The format is based on the action's source ({@link CreateActionPayload.pluginName} or 'application') and {@link CreateActionPayload.uid}.
+ * @param {CreateActionPayload} attributes
+ * @return {string}
+ */
+const computeActionId = attributes => {
+  const { pluginName, uid } = attributes;
+
+  if (!pluginName) {
+    return `application::${uid}`;
+  }
+
+  if (pluginName === 'admin') {
+    return `admin::${uid}`;
+  }
+
+  return `plugins::${pluginName}.${uid}`;
+};
+
+/**
+ * Assign an actionId attribute to an {@link CreateActionPayload} object
+ * @param {CreateActionPayload} attrs - Payload used to create an action
+ * @return {CreateActionPayload}
+ */
+const assignActionId = attrs => set('actionId', computeActionId(attrs), attrs);
+
+/**
+ * Transform an action by adding or removing the {@link Action.subCategory} attribute
+ * @param {Action} action - The action to process
+ * @return {Action}
+ */
+const assignOrOmitSubCategory = action => {
+  const shouldHaveSubCategory = ['settings', 'plugins'].includes(action.section);
+
+  return shouldHaveSubCategory
+    ? set('subCategory', action.subCategory || 'general', action)
+    : omit('subCategory', action);
+};
+
+/**
+ * Check if a property can be applied to an {@link Action}
+ * @type (function(property: string, action: Action): boolean) | (function(property: string): (function(action: Action): boolean))
+ * @return {boolean} Return true if the property can be applied for the given action
+ */
+const appliesToProperty = curry((property, action) => {
+  return pipe(prop('options.applyToProperties'), includes(property))(action);
+});
+
+/**
+ * Check if an action applies to a subject
+ * @param {string} subject
+ * @param {Action} action
+ * @return {boolean}
+ */
+const appliesToSubject = curry((subject, action) => {
+  return isArray(action.subjects) && includes(subject, action.subjects);
+});
+
+/**
+ * Transform the given attributes into a domain representation of an Action
+ * @type (function(payload: CreateActionPayload): Action)
+ * @param {CreateActionPayload} payload - The action payload containing the attributes needed to create an {@link Action}
+ * @return {Action} A newly created {@link Action}
+ */
+const create = pipe(
+  // Create and assign an action identifier to the action
+  // (need to be done before the sanitizeActionAttributes since we need the uid here)
+  assignActionId,
+  // Add or remove the sub category field based on the pluginName attribute
+  assignOrOmitSubCategory,
+  // Remove unwanted attributes from the payload
+  sanitizeActionAttributes,
+  // Complete the action creation by adding default values for some attributes
+  merge(getDefaultActionAttributes())
+);
+
+module.exports = {
+  actionFields,
+  appliesToProperty,
+  appliesToSubject,
+  assignActionId,
+  assignOrOmitSubCategory,
+  create,
+  computeActionId,
+  getDefaultActionAttributes,
+  sanitizeActionAttributes,
+};

package/domain/action/provider.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { providerFactory, hooks } = require('@akemona-org/strapi-utils');
+const { validateRegisterProviderAction } = require('../../validation/action-provider');
+const domain = require('./index');
+
+/**
+ * @typedef ActionProviderOverride
+ * @property {function(CreateActionPayload)} register
+ * @property {function(attributes CreateActionPayload[]): Promise<this>} registerMany
+ */
+
+/**
+ * Creates a new instance of an action provider
+ * @return {Provider & ActionProviderOverride}
+ */
+const createActionProvider = (options) => {
+  const provider = providerFactory(options);
+  const actionHooks = {
+    appliesPropertyToSubject: hooks.createAsyncParallelHook(),
+  };
+
+  return {
+    ...provider,
+
+    hooks: {
+      ...provider.hooks,
+      ...actionHooks,
+    },
+
+    async register(actionAttributes) {
+      if (strapi.isLoaded) {
+        throw new Error(`You can't register new actions outside of the bootstrap function.`);
+      }
+
+      validateRegisterProviderAction([actionAttributes]);
+
+      const action = domain.create(actionAttributes);
+
+      return provider.register(action.actionId, action);
+    },
+
+    async registerMany(actionsAttributes) {
+      validateRegisterProviderAction(actionsAttributes);
+
+      for (const attributes of actionsAttributes) {
+        await this.register(attributes);
+      }
+
+      return this;
+    },
+
+    async appliesToProperty(property, actionId, subject) {
+      const action = provider.get(actionId);
+      const appliesToAction = domain.appliesToProperty(property, action);
+
+      // If the property isn't valid for this action, ignore the rest of the checks
+      if (!appliesToAction) {
+        return false;
+      }
+
+      // If the property is valid for this action and there isn't any subject
+      if (!subject) {
+        return true;
+      }
+
+      // If the property is valid for this action and the subject is not handled by the action
+      if (!domain.appliesToSubject(subject, action)) {
+        return false;
+      }
+
+      const results = await actionHooks.appliesPropertyToSubject.call({
+        property,
+        action,
+        subject,
+      });
+
+      return results.every((result) => result !== false);
+    },
+  };
+};
+
+module.exports = createActionProvider;

package/domain/condition/index.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const { pipe, merge, set, pick } = require('lodash/fp');
+
+/**
+ * The handler of a {@link Condition}
+ * @typedef {(function(user: Object, options: Object): Object | boolean)} ConditionHandler
+ */
+/**
+ * Domain representation of a Condition (RBAC)
+ * @typedef {Object} Condition
+ * @property {string} id - The identifier of the condition
+ * @property {string} displayName - The display name of a condition
+ * @property {string} name - The name of a condition
+ * @property {string} [plugin] - The plugin which provide the condition
+ * @property {string} [category] - The main category of a condition
+ * @property {ConditionHandler} handler - The handler of a condition
+ */
+
+/**
+ * Set of attributes used to create a new {@link Action} object
+ * @typedef {Condition, { uid: string }} CreateConditionPayload
+ */
+
+const DEFAULT_CATEGORY = 'default';
+
+/**
+ * Get the default value used for every condition
+ * @return {Condition}
+ */
+const getDefaultConditionAttributes = () => ({
+  category: DEFAULT_CATEGORY,
+});
+
+/**
+ * Get the list of all the valid attributes of a {@link Condition}
+ * @return {string[]}
+ */
+const conditionFields = ['id', 'displayName', 'handler', 'plugin', 'category'];
+
+/**
+ * Remove unwanted attributes from a {@link Condition}
+ * @type {function(action: Condition | CreateConditionPayload): Condition}
+ */
+const sanitizeConditionAttributes = pick(conditionFields);
+
+/**
+ *
+ * @param condition
+ * @return {string}
+ */
+const computeConditionId = condition => {
+  const { name, plugin } = condition;
+
+  if (!plugin) {
+    return `application::${name}`;
+  }
+
+  if (plugin === 'admin') {
+    return `admin::${name}`;
+  }
+
+  return `plugins::${plugin}.${name}`;
+};
+
+/**
+ * Assign an id attribute to a {@link CreateConditionPayload} object
+ * @param {CreateConditionPayload} attrs - Payload used to create a condition
+ * @return {CreateConditionPayload}
+ */
+const assignConditionId = attrs => set('id', computeConditionId(attrs), attrs);
+
+/**
+ * Transform the given attributes into a domain representation of a Condition
+ * @type (function(CreateConditionPayload): Condition)
+ * @param {CreateConditionPayload} payload - The condition payload containing the attributes needed to create a {@link Condition}
+ * @return {Condition}
+ */
+const create = pipe(
+  assignConditionId,
+  sanitizeConditionAttributes,
+  merge(getDefaultConditionAttributes())
+);
+
+module.exports = {
+  assignConditionId,
+  computeConditionId,
+  conditionFields,
+  create,
+  getDefaultConditionAttributes,
+  sanitizeConditionAttributes,
+};

package/domain/condition/provider.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const { providerFactory } = require('@akemona-org/strapi-utils');
+const domain = require('./');
+
+/**
+ * @typedef ConditionProviderOverride
+ * @property {function(CreateConditionPayload)} register
+ * @property {function(attributes CreateConditionPayload[]): Promise<this>} registerMany
+ */
+
+/**
+ * Creates a new instance of a condition provider
+ * @return {Provider & ConditionProviderOverride}
+ */
+const createConditionProvider = () => {
+  const provider = providerFactory();
+
+  return {
+    ...provider,
+
+    async register(conditionAttributes) {
+      if (strapi.isLoaded) {
+        throw new Error(`You can't register new conditions outside of the bootstrap function.`);
+      }
+
+      const condition = domain.create(conditionAttributes);
+
+      return provider.register(condition.id, condition);
+    },
+
+    async registerMany(conditionsAttributes) {
+      for (const attributes of conditionsAttributes) {
+        await this.register(attributes);
+      }
+
+      return this;
+    },
+  };
+};
+
+module.exports = createConditionProvider;

package/domain/permission/index.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const {
+  pipe,
+  set,
+  pick,
+  eq,
+  omit,
+  remove,
+  get,
+  uniq,
+  isArray,
+  map,
+  curry,
+  merge,
+} = require('lodash/fp');
+
+/**
+ * Domain representation of a Permission (RBAC)
+ * @typedef {Object} Permission
+ * @property {string} [id] - The unique identifier of the permission
+ * @property {string} [role] - The role associated to a permission
+ * @property {string} action - The human readable name of an action
+ * @property {string} properties - A set of properties used to define the permission with more granularity
+ * @property {string} conditions - Conditions to check when evaluating the permission
+ * @property {string} subject - The subject on which the permission should applies
+ */
+
+const permissionFields = ['id', 'action', 'subject', 'properties', 'conditions', 'role'];
+const sanitizedPermissionFields = ['id', 'action', 'subject', 'properties', 'conditions'];
+
+const sanitizePermissionFields = pick(sanitizedPermissionFields);
+
+/**
+ * Creates a permission with default values
+ * @return {Permission}
+ */
+const getDefaultPermission = () => ({
+  conditions: [],
+  properties: {},
+  subject: null,
+});
+
+/**
+ * Returns a new permission with the given condition
+ * @param {string} condition - The condition to add
+ * @param {Permission} permission - The permission on which we want to add the condition
+ * @return {Permission}
+ */
+const addCondition = curry((condition, permission) => {
+  const { conditions } = permission;
+  const newConditions = Array.isArray(conditions)
+    ? uniq(conditions.concat(condition))
+    : [condition];
+
+  return set('conditions', newConditions, permission);
+});
+
+/**
+ * Returns a new permission without the given condition
+ * @param {string} condition - The condition to remove
+ * @param {Permission} permission - The permission on which we want to remove the condition
+ * @return {Permission}
+ */
+const removeCondition = curry((condition, permission) => {
+  return set('conditions', remove(eq(condition), permission.conditions), permission);
+});
+
+/**
+ * Gets a property or a part of a property from a permission.
+ * @param {string} property - The property to get
+ * @param {Permission} permission - The permission on which we want to access the property
+ * @return {Permission}
+ */
+const getProperty = curry((property, permission) => get(`properties.${property}`, permission));
+
+/**
+ * Set a value for a given property on a new permission object
+ * @param {string} property - The name of the property
+ * @param {any} value - The value of the property
+ * @param {Permission} permission - The permission on which we want to set the property
+ * @return {Permission}
+ */
+const setProperty = (property, value, permission) => {
+  return set(`properties.${property}`, value, permission);
+};
+
+/**
+ * Returns a new permission without the given property name set
+ * @param {string} property - The name of the property to delete
+ * @param {Permission} permission - The permission on which we want to remove the property
+ * @return {Permission}
+ */
+const deleteProperty = (property, permission) => omit(`properties.${property}`, permission);
+
+/**
+ * Creates a new {@link Permission} object from raw attributes. Set default values for certain fields
+ * @param {Permission} attributes
+ * @return {Permission}
+ */
+const create = attributes => {
+  return pipe(pick(permissionFields), merge(getDefaultPermission()))(attributes);
+};
+
+/**
+ * Using the given condition provider, check and remove invalid condition from the permission's condition array.
+ * @param {object} provider - The condition provider used to do the checks
+ * @param {Permission} permission - The condition to sanitize
+ * @return {Permission}
+ */
+const sanitizeConditions = curry((provider, permission) => {
+  if (!isArray(permission.conditions)) {
+    return permission;
+  }
+
+  return permission.conditions
+    .filter(condition => !provider.has(condition))
+    .reduce((perm, condition) => removeCondition(condition, perm), permission);
+});
+
+/**
+ * Transform raw attributes into valid permissions using the create domain function.
+ * @param {object | object[]} payload - Can either be a single object of attributes or an array of those objects.
+ * @return {Permission | Permission[]}
+ */
+const toPermission = payload => (isArray(payload) ? map(create, payload) : create(payload));
+
+module.exports = {
+  addCondition,
+  removeCondition,
+  create,
+  deleteProperty,
+  permissionFields,
+  getProperty,
+  sanitizedPermissionFields,
+  sanitizeConditions,
+  sanitizePermissionFields,
+  setProperty,
+  toPermission,
+};

package/domain/role.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const {
+  contentTypes: { hasDraftAndPublish },
+} = require('@akemona-org/strapi-utils');
+const {
+  AUTHOR_CODE,
+  PUBLISH_ACTION,
+  DELETE_ACTION,
+  UPDATE_ACTION,
+  CREATE_ACTION,
+  READ_ACTION,
+} = require('../services/constants');
+
+const BOUND_ACTIONS = [READ_ACTION, CREATE_ACTION, UPDATE_ACTION, DELETE_ACTION, PUBLISH_ACTION];
+
+const BOUND_ACTIONS_FOR_FIELDS = [READ_ACTION, CREATE_ACTION, UPDATE_ACTION];
+
+const getBoundActionsBySubject = (role, subject) => {
+  const model = strapi.getModel(subject);
+
+  if (role.code === AUTHOR_CODE || !hasDraftAndPublish(model)) {
+    return [READ_ACTION, UPDATE_ACTION, CREATE_ACTION, DELETE_ACTION];
+  }
+
+  return BOUND_ACTIONS;
+};
+
+module.exports = { getBoundActionsBySubject, BOUND_ACTIONS, BOUND_ACTIONS_FOR_FIELDS };

package/domain/user.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { SUPER_ADMIN_CODE } = require('../services/constants');
+
+/**
+ * Create a new user model by merging default and specified attributes
+ * @param attributes A partial user object
+ */
+function createUser(attributes) {
+  return {
+    roles: [],
+    isActive: false,
+    username: null,
+    ...attributes,
+  };
+}
+
+const hasSuperAdminRole = user => {
+  return user.roles.filter(role => role.code === SUPER_ADMIN_CODE).length > 0;
+};
+
+module.exports = {
+  createUser,
+  hasSuperAdminRole,
+};

package/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <!-- The first thing in any HTML file should be the charset -->
+  <meta charset="utf-8">
+  <!-- Make the page mobile compatible -->
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="mobile-web-app-capable" content="yes">
+  <title>Strapi Admin</title>
+</head>
+<body>
+<!-- The app hooks into this div -->
+<div id="app"></div>
+<!-- A lot of magic happens in this file. HtmlWebpackPlugin automatically includes all assets (e.g. bundle.js, main.css) with the correct HTML tags, which is why they are missing in this HTML file. Don't add any assets here! (Check out webpackconfig.js if you want to know more) -->
+</body>
+</html>