@akemona-org/strapi-admin 3.7.0

package/admin/src/utils/reducerInjectors.js

@@ -0,0 +1,38 @@
+/* eslint-disable */
+
+import invariant from 'invariant';
+import isEmpty from 'lodash/isEmpty';
+import isFunction from 'lodash/isFunction';
+import isString from 'lodash/isString';
+
+import createReducer from '../reducers';
+import checkStore from './checkStore';
+
+export function injectReducerFactory(store, isValid) {
+  return function injectReducer(key, reducer) {
+    if (!isValid) checkStore(store);
+
+    invariant(
+      isString(key) && !isEmpty(key) && isFunction(reducer),
+      '(app/utils...) injectReducer: Expected `reducer` to be a reducer function'
+    );
+
+    // Check `store.injectedReducers[key] === reducer` for hot reloading when a key is the same but a reducer is different
+    if (
+      Reflect.has(store.injectedReducers, key) &&
+      store.injectedReducers[key] === reducer
+    )
+      return;
+
+    store.injectedReducers[key] = reducer; // eslint-disable-line no-param-reassign
+    store.replaceReducer(createReducer(store.injectedReducers));
+  };
+}
+
+export default function getInjectors(store) {
+  checkStore(store);
+
+  return {
+    injectReducer: injectReducerFactory(store, true),
+  };
+}

package/admin/src/utils/retrieveGlobalLinks.js

@@ -0,0 +1,17 @@
+import { get } from 'lodash';
+
+const retrieveGlobalLinks = pluginsObj => {
+  return Object.values(pluginsObj).reduce((acc, current) => {
+    const links = get(current, ['settings', 'global', 'links'], null);
+
+    if (links) {
+      for (let i = 0; i < links.length; i++) {
+        acc.push(links[i]);
+      }
+    }
+
+    return acc;
+  }, []);
+};
+
+export default retrieveGlobalLinks;

package/admin/src/utils/retrievePluginsMenu.js

@@ -0,0 +1,17 @@
+import { get } from 'lodash';
+
+const retrievePluginsMenu = pluginsObj => {
+  return Object.values(pluginsObj).reduce((acc, current) => {
+    const pluginMenu = get(current, ['settings', 'menuSection'], null);
+
+    if (!pluginMenu) {
+      return acc;
+    }
+
+    acc.push(pluginMenu);
+
+    return acc;
+  }, []);
+};
+
+export default retrievePluginsMenu;

package/admin/src/utils/sagaInjectors.js

@@ -0,0 +1,94 @@
+/* eslint-disable */
+
+import isEmpty from 'lodash/isEmpty';
+import isFunction from 'lodash/isFunction';
+import isString from 'lodash/isString';
+import invariant from 'invariant';
+import conformsTo from 'lodash/conformsTo';
+
+import checkStore from './checkStore';
+import { DAEMON, ONCE_TILL_UNMOUNT, RESTART_ON_REMOUNT } from './constants';
+
+const allowedModes = [RESTART_ON_REMOUNT, DAEMON, ONCE_TILL_UNMOUNT];
+
+const checkKey = key =>
+  invariant(
+    isString(key) && !isEmpty(key),
+    '(app/utils...) injectSaga: Expected `key` to be a non empty string'
+  );
+
+const checkDescriptor = descriptor => {
+  const shape = {
+    saga: isFunction,
+    mode: mode => isString(mode) && allowedModes.includes(mode),
+  };
+  invariant(
+    conformsTo(descriptor, shape),
+    '(app/utils...) injectSaga: Expected a valid saga descriptor'
+  );
+};
+
+export function injectSagaFactory(store, isValid) {
+  return function injectSaga(key, descriptor = {}, args) {
+    if (!isValid) checkStore(store);
+
+    const newDescriptor = {
+      ...descriptor,
+      mode: descriptor.mode || RESTART_ON_REMOUNT,
+    };
+    const { saga, mode } = newDescriptor;
+
+    checkKey(key);
+    checkDescriptor(newDescriptor);
+
+    let hasSaga = Reflect.has(store.injectedSagas, key);
+
+    if (process.env.NODE_ENV !== 'production') {
+      const oldDescriptor = store.injectedSagas[key];
+      // enable hot reloading of daemon and once-till-unmount sagas
+      if (hasSaga && oldDescriptor.saga !== saga) {
+        oldDescriptor.task.cancel();
+        hasSaga = false;
+      }
+    }
+
+    if (
+      !hasSaga ||
+      (hasSaga && mode !== DAEMON && mode !== ONCE_TILL_UNMOUNT)
+    ) {
+      store.injectedSagas[key] = {
+        ...newDescriptor,
+        task: store.runSaga(saga, args),
+      }; // eslint-disable-line no-param-reassign
+    }
+  };
+}
+
+export function ejectSagaFactory(store, isValid) {
+  return function ejectSaga(key) {
+    if (!isValid) checkStore(store);
+
+    checkKey(key);
+
+    if (Reflect.has(store.injectedSagas, key)) {
+      const descriptor = store.injectedSagas[key];
+      if (descriptor.mode !== DAEMON) {
+        descriptor.task.cancel();
+        // Clean up in production; in development we need `descriptor.saga` for hot reloading
+        if (process.env.NODE_ENV === 'production') {
+          // Need some value to be able to detect `ONCE_TILL_UNMOUNT` sagas in `injectSaga`
+          store.injectedSagas[key] = 'done'; // eslint-disable-line no-param-reassign
+        }
+      }
+    }
+  };
+}
+
+export default function getInjectors(store) {
+  checkStore(store);
+
+  return {
+    injectSaga: injectSagaFactory(store, true),
+    ejectSaga: ejectSagaFactory(store, true),
+  };
+}

package/admin/src/utils/sortLinks.js

@@ -0,0 +1,5 @@
+import { sortBy } from 'lodash';
+
+const sortLinks = links => sortBy(links, object => object.name);
+
+export default sortLinks;

package/admin/src/validations/users/edit.js

@@ -0,0 +1,11 @@
+import * as yup from 'yup';
+import profileValidation from './profile';
+import rolesValidation from './roles';
+
+const schema = yup.object().shape({
+  ...profileValidation,
+  isActive: yup.bool(),
+  ...rolesValidation,
+});
+
+export default schema;

package/admin/src/validations/users/index.js

@@ -0,0 +1,3 @@
+export { default as editValidation } from './edit';
+export { default as profileValidation } from './profile';
+export { default as rolesValidation } from './roles';

package/admin/src/validations/users/profile.js

@@ -0,0 +1,29 @@
+import * as yup from 'yup';
+import { translatedErrors } from 'strapi-helper-plugin';
+
+const schema = {
+  firstname: yup.mixed().required(translatedErrors.required),
+  lastname: yup.mixed().required(translatedErrors.required),
+  email: yup
+    .string()
+    .email(translatedErrors.email)
+    .lowercase()
+    .required(translatedErrors.required),
+  username: yup.string().nullable(),
+  password: yup
+    .string()
+    .min(8, translatedErrors.minLength)
+    .matches(/[a-z]/, 'components.Input.error.contain.lowercase')
+    .matches(/[A-Z]/, 'components.Input.error.contain.uppercase')
+    .matches(/\d/, 'components.Input.error.contain.number'),
+  confirmPassword: yup
+    .string()
+    .min(8, translatedErrors.minLength)
+    .oneOf([yup.ref('password'), null], 'components.Input.error.password.noMatch')
+    .when('password', (password, passSchema) => {
+      return password ? passSchema.required(translatedErrors.required) : passSchema;
+    }),
+  preferedLanguage: yup.string().nullable(),
+};
+
+export default schema;

package/admin/src/validations/users/roles.js

@@ -0,0 +1,11 @@
+import * as yup from 'yup';
+import { translatedErrors } from 'strapi-helper-plugin';
+
+const schema = {
+  roles: yup
+    .array()
+    .min(1)
+    .required(translatedErrors.required),
+};
+
+export default schema;

package/config/admin-actions.js

@@ -0,0 +1,122 @@
+'use strict';
+
+module.exports = {
+  actions: [
+    {
+      uid: 'marketplace.read',
+      displayName: 'Access the marketplace',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'plugins and marketplace',
+      subCategory: 'marketplace',
+    },
+    {
+      uid: 'marketplace.plugins.install',
+      displayName: 'Install (only for dev env)',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'plugins and marketplace',
+      subCategory: 'plugins',
+    },
+    {
+      uid: 'marketplace.plugins.uninstall',
+      displayName: 'Uninstall (only for dev env)',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'plugins and marketplace',
+      subCategory: 'plugins',
+    },
+    {
+      uid: 'webhooks.create',
+      displayName: 'Create',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'webhooks',
+    },
+    {
+      uid: 'webhooks.read',
+      displayName: 'Read',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'webhooks',
+    },
+    {
+      uid: 'webhooks.update',
+      displayName: 'Update',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'webhooks',
+    },
+    {
+      uid: 'webhooks.delete',
+      displayName: 'Delete',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'webhooks',
+    },
+    {
+      uid: 'users.create',
+      displayName: 'Create (invite)',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'users and roles',
+      subCategory: 'users',
+    },
+    {
+      uid: 'users.read',
+      displayName: 'Read',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'users and roles',
+      subCategory: 'users',
+    },
+    {
+      uid: 'users.update',
+      displayName: 'Update',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'users and roles',
+      subCategory: 'users',
+    },
+    {
+      uid: 'users.delete',
+      displayName: 'Delete',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'users and roles',
+      subCategory: 'users',
+    },
+    {
+      uid: 'roles.create',
+      displayName: 'Create',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'users and roles',
+      subCategory: 'roles',
+    },
+    {
+      uid: 'roles.read',
+      displayName: 'Read',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'users and roles',
+      subCategory: 'roles',
+    },
+    {
+      uid: 'roles.update',
+      displayName: 'Update',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'users and roles',
+      subCategory: 'roles',
+    },
+    {
+      uid: 'roles.delete',
+      displayName: 'Delete',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'users and roles',
+      subCategory: 'roles',
+    },
+  ],
+};

package/config/admin-conditions.js

@@ -0,0 +1,26 @@
+'use strict';
+
+module.exports = {
+  conditions: [
+    {
+      displayName: 'Is creator',
+      name: 'is-creator',
+      plugin: 'admin',
+      handler: user => ({ 'created_by.id': user.id }),
+    },
+    {
+      displayName: 'Has same role as creator',
+      name: 'has-same-role-as-creator',
+      plugin: 'admin',
+      handler: user => ({
+        'created_by.roles': {
+          $elemMatch: {
+            id: {
+              $in: user.roles.map(r => r.id),
+            },
+          },
+        },
+      }),
+    },
+  ],
+};

package/config/email-templates/forgot-password.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const subject = `Reset password`;
+
+const html = `<p>We heard that you lost your password. Sorry about that!</p>
+
+<p>But don’t worry! You can use the following link to reset your password:</p>
+
+<p><%= url %></p>
+
+<p>Thanks.</p>`;
+
+const text = `We heard that you lost your password. Sorry about that!
+
+But don’t worry! You can use the following link to reset your password:
+
+<%= url %>
+
+Thanks.`;
+
+module.exports = {
+  subject,
+  text,
+  html,
+};

package/config/functions/bootstrap.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const { merge } = require('lodash/fp');
+const { getService } = require('../../utils');
+const adminActions = require('../admin-actions');
+const adminConditions = require('../admin-conditions');
+
+const defaultAdminAuthSettings = {
+  providers: {
+    autoRegister: false,
+    defaultRole: null,
+  },
+};
+
+const registerPermissionActions = () => {
+  getService('permission').actionProvider.registerMany(adminActions.actions);
+};
+
+const registerAdminConditions = () => {
+  getService('permission').conditionProvider.registerMany(adminConditions.conditions);
+};
+
+const syncAuthSettings = async () => {
+  const adminStore = await strapi.store({ type: 'core', environment: '', name: 'admin' });
+  const adminAuthSettings = await adminStore.get({ key: 'auth' });
+  const newAuthSettings = merge(defaultAdminAuthSettings, adminAuthSettings);
+
+  const roleExists = await strapi.admin.services.role.exists({
+    id: newAuthSettings.providers.defaultRole,
+  });
+
+  // Reset the default SSO role if it has been deleted manually
+  if (!roleExists) {
+    newAuthSettings.providers.defaultRole = null;
+  }
+
+  await adminStore.set({ key: 'auth', value: newAuthSettings });
+};
+
+module.exports = async () => {
+  registerAdminConditions();
+  registerPermissionActions();
+
+  const permissionService = getService('permission');
+  const userService = getService('user');
+  const roleService = getService('role');
+
+  await userService.migrateUsers();
+
+  await roleService.createRolesIfNoneExist();
+  await roleService.resetSuperAdminPermissions();
+  await roleService.displayWarningIfNoSuperAdmin();
+
+  await permissionService.ensureBoundPermissionsInDatabase();
+  await permissionService.cleanPermissionsInDatabase();
+
+  await userService.displayWarningIfUsersDontHaveRole();
+
+  await syncAuthSettings();
+
+  strapi.admin.destroy = async () => {
+    const { conditionProvider, actionProvider } = getService('permission');
+
+    await conditionProvider.clear();
+    await actionProvider.clear();
+  };
+};

package/config/functions/register.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const permissionsFieldsToPropertiesMigration = require('../migrations/permissions-fields-to-properties');
+
+module.exports = () => {
+  strapi.db.migrations.register(permissionsFieldsToPropertiesMigration);
+};

package/config/layout.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = {
+  administrator: {
+    actions: {
+      create: 'Admin.create',
+      update: 'Admin.update',
+    },
+  },
+};

package/config/migrations/permissions-fields-to-properties.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const { has, isObject } = require('lodash/fp');
+
+const permissionModelUID = 'strapi::permission';
+
+const hasAttribute = attribute => has(`attributes.${attribute}`);
+const hasFieldsAttribute = hasAttribute('fields');
+const hasPropertiesAttribute = hasAttribute('properties');
+
+const shouldRunMigration = (definition, previousDefinition) => {
+  const isAdminPermissionModel = definition.uid === permissionModelUID;
+
+  const hadFieldsButNotProperties =
+    hasFieldsAttribute(previousDefinition) && !hasPropertiesAttribute(previousDefinition);
+
+  const hasPropertiesButNotFields =
+    !hasFieldsAttribute(definition) && hasPropertiesAttribute(definition);
+
+  const targetedFieldsHaveChanged = hadFieldsButNotProperties && hasPropertiesButNotFields;
+
+  return isAdminPermissionModel && targetedFieldsHaveChanged;
+};
+
+const permissionsFinderByORM = {
+  async bookshelf(model) {
+    const permissions = await model.fetchAll();
+
+    return permissions.toJSON().map(permission => {
+      const fields = permission.fields;
+
+      return {
+        ...permission,
+        fields: isObject(fields) ? fields : JSON.parse(fields),
+      };
+    });
+  },
+
+  async mongoose(model) {
+    return model.find().lean();
+  },
+};
+
+module.exports = {
+  shouldRun: {
+    before(options) {
+      const { definition, previousDefinition } = options;
+
+      return shouldRunMigration(definition, previousDefinition);
+    },
+
+    after(options, context) {
+      const { definition, previousDefinition } = options;
+      const { permissionsFieldsToProperties = {} } = context;
+      const { permissions = [] } = permissionsFieldsToProperties;
+
+      return shouldRunMigration(definition, previousDefinition) && permissions.length > 0;
+    },
+  },
+
+  // Here we make a backup of the permission objects in the database, then we store it into the migration context
+  async before(options, context) {
+    const { model } = options;
+
+    const permissions = await permissionsFinderByORM[model.orm](model);
+
+    Object.assign(context, { permissionsFieldsToProperties: { permissions } });
+  },
+
+  // Based on the permissions sent in the context, we perform an update. { fields } => { properties: { fields } }
+  async after(options, context) {
+    const { model, ORM } = options;
+    const { permissionsFieldsToProperties = {} } = context;
+    const { permissions = [] } = permissionsFieldsToProperties;
+
+    if (model.orm === 'bookshelf') {
+      const update = async transacting => {
+        for (const permission of permissions) {
+          const { fields, ...rest } = permission;
+
+          await model
+            .forge({ id: rest.id })
+            .save({ properties: { fields } }, { patch: true, transacting });
+        }
+      };
+
+      await ORM.transaction(transacting => update(transacting));
+    }
+
+    if (model.orm === 'mongoose') {
+      for (const permission of permissions) {
+        const { fields, _id } = permission;
+
+        await model.updateOne(
+          { _id },
+          {
+            $set: { properties: { fields } },
+            $unset: { fields: true },
+          }
+        );
+      }
+    }
+  },
+};

package/config/policies/hasPermissions.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const _ = require('lodash');
+const {
+  policy: { createPolicyFactory },
+} = require('@akemona-org/strapi-utils');
+const { validateHasPermissionsInput } = require('../../validation/policies/hasPermissions');
+
+const inputModifiers = [
+  {
+    check: _.isString,
+    transform: (action) => ({ action }),
+  },
+  {
+    check: _.isArray,
+    transform: (arr) => ({ action: arr[0], subject: arr[1] }),
+  },
+  {
+    // Has to be after the isArray check since _.isObject also matches arrays
+    check: _.isObject,
+    transform: (perm) => perm,
+  },
+];
+
+module.exports = createPolicyFactory(
+  (input) => {
+    const permissions = input.map((val) =>
+      inputModifiers.find((modifier) => modifier.check(val)).transform(val)
+    );
+
+    return (ctx, next) => {
+      const { userAbility: ability, isAuthenticatedAdmin } = ctx.state;
+
+      if (!isAuthenticatedAdmin || !ability) {
+        return next();
+      }
+
+      const isAuthorized = permissions.every(({ action, subject }) => ability.can(action, subject));
+
+      if (!isAuthorized) {
+        throw strapi.errors.forbidden();
+      }
+
+      return next();
+    };
+  },
+  {
+    validator: validateHasPermissionsInput,
+    name: 'admin::hasPermissions',
+  }
+);

package/config/policies/isAuthenticatedAdmin.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = (ctx, next) => {
+  if (!ctx.state.isAuthenticatedAdmin) {
+    throw strapi.errors.forbidden();
+  }
+
+  return next();
+};