@strapi/admin 4.13.3 → 4.14.0-alpha.0

package/server/validation/common-validators.js

@@ -89,112 +89,103 @@ const fieldsPropertyValidation = (action) =>
       checkNilFields(action)
     );
 
+const permission = yup
+  .object()
+  .shape({
+    action: yup
+      .string()
+      .required()
+      .test('action-validity', 'action is not an existing permission action', function (actionId) {
+        // If the action field is Nil, ignore the test and let the required check handle the error
+        if (isNil(actionId)) {
+          return true;
+        }
+
+        return !!getActionFromProvider(actionId);
+      }),
+    actionParameters: yup.object().nullable(),
+    subject: yup
+      .string()
+      .nullable()
+      .test('subject-validity', 'Invalid subject submitted', function (subject) {
+        const action = getActionFromProvider(this.options.parent.action);
+
+        if (!action) {
+          return true;
+        }
+
+        if (isNil(action.subjects)) {
+          return isNil(subject);
+        }
+
+        if (isArray(action.subjects)) {
+          return action.subjects.includes(subject);
+        }
+
+        return false;
+      }),
+    properties: yup
+      .object()
+      .test('properties-structure', 'Invalid property set at ${path}', function (properties) {
+        const action = getActionFromProvider(this.options.parent.action);
+        const hasNoProperties = isEmpty(properties) || isNil(properties);
+
+        if (!has('options.applyToProperties', action)) {
+          return hasNoProperties;
+        }
+
+        if (hasNoProperties) {
+          return true;
+        }
+
+        const { applyToProperties } = action.options;
+
+        if (!isArray(applyToProperties)) {
+          return false;
+        }
+
+        return Object.keys(properties).every((property) => applyToProperties.includes(property));
+      })
+      .test(
+        'fields-property',
+        'Invalid fields property at ${path}',
+        async function (properties = {}) {
+          const action = getActionFromProvider(this.options.parent.action);
+
+          if (!action || !properties) {
+            return true;
+          }
+
+          if (!actionDomain.appliesToProperty('fields', action)) {
+            return true;
+          }
+
+          try {
+            await fieldsPropertyValidation(action).validate(properties.fields, {
+              strict: true,
+              abortEarly: false,
+            });
+            return true;
+          } catch (e) {
+            // Propagate fieldsPropertyValidation error with updated path
+            throw this.createError({
+              message: e.message,
+              path: `${this.path}.fields`,
+            });
+          }
+        }
+      ),
+    conditions: yup.array().of(yup.string()),
+  })
+  .noUnknown();
+
 const updatePermissions = yup
   .object()
   .shape({
     permissions: yup
       .array()
       .required()
-      .of(
-        yup
-          .object()
-          .shape({
-            action: yup
-              .string()
-              .required()
-              .test(
-                'action-validity',
-                'action is not an existing permission action',
-                function (actionId) {
-                  // If the action field is Nil, ignore the test and let the required check handle the error
-                  if (isNil(actionId)) {
-                    return true;
-                  }
-
-                  return !!getActionFromProvider(actionId);
-                }
-              ),
-            subject: yup
-              .string()
-              .nullable()
-              .test('subject-validity', 'Invalid subject submitted', function (subject) {
-                const action = getActionFromProvider(this.options.parent.action);
-
-                if (!action) {
-                  return true;
-                }
-
-                if (isNil(action.subjects)) {
-                  return isNil(subject);
-                }
-
-                if (isArray(action.subjects)) {
-                  return action.subjects.includes(subject);
-                }
-
-                return false;
-              }),
-            properties: yup
-              .object()
-              .test(
-                'properties-structure',
-                'Invalid property set at ${path}',
-                function (properties) {
-                  const action = getActionFromProvider(this.options.parent.action);
-                  const hasNoProperties = isEmpty(properties) || isNil(properties);
-
-                  if (!has('options.applyToProperties', action)) {
-                    return hasNoProperties;
-                  }
-
-                  if (hasNoProperties) {
-                    return true;
-                  }
-
-                  const { applyToProperties } = action.options;
-
-                  if (!isArray(applyToProperties)) {
-                    return false;
-                  }
-
-                  return Object.keys(properties).every((property) =>
-                    applyToProperties.includes(property)
-                  );
-                }
-              )
-              .test(
-                'fields-property',
-                'Invalid fields property at ${path}',
-                async function (properties = {}) {
-                  const action = getActionFromProvider(this.options.parent.action);
-
-                  if (!action || !properties) {
-                    return true;
-                  }
-
-                  if (!actionDomain.appliesToProperty('fields', action)) {
-                    return true;
-                  }
-
-                  try {
-                    await fieldsPropertyValidation(action).validate(properties.fields, {
-                      strict: true,
-                      abortEarly: false,
-                    });
-                    return true;
-                  } catch (e) {
-                    // Propagate fieldsPropertyValidation error with updated path
-                    throw this.createError({
-                      message: e.message,
-                      path: `${this.path}.fields`,
-                    });
-                  }
-                }
-              ),
-            conditions: yup.array().of(yup.string()),
-          })
-          .noUnknown()
-      )
+      .of(permission)
       .test(
         'duplicated-permissions',
         'Some permissions are duplicated (same action and subject)',
@@ -213,5 +204,6 @@ module.exports = {
   roles,
   isAPluginName,
   arrayOfConditionNames,
+  permission,
   updatePermissions,
 };

package/server/validation/permission.js

@@ -17,8 +17,6 @@ const checkPermissionsSchema = yup.object().shape({
   ),
 });
 
-// validatePermissionsExist
-
 const checkPermissionsExist = function (permissions) {
   const existingActions = getService('permission').actionProvider.values();
   const failIndex = permissions.findIndex(
@@ -48,7 +46,6 @@ const actionsExistSchema = yup
   .test('actions-exist', '', checkPermissionsExist);
 
 // exports
-
 module.exports = {
   validatedUpdatePermissionsInput: validateYupSchema(validators.updatePermissions),
   validatePermissionsExist: validateYupSchema(actionsExistSchema),

package/utils/create-cache-dir.js

@@ -1,69 +1,13 @@
 'use strict';
 
 const path = require('path');
-const _ = require('lodash');
 const fs = require('fs-extra');
 const tsUtils = require('@strapi/typescript-utils');
 const getCustomAppConfigFile = require('./get-custom-app-config-file');
+const { filterPluginsByAdminEntry, createPluginFile } = require('./plugins');
 
 const getPkgPath = (name) => path.dirname(require.resolve(`${name}/package.json`));
 
-async function createPluginsJs(plugins, dest) {
-  const pluginsArray = plugins.map(({ pathToPlugin, name, info }) => {
-    const shortName = _.camelCase(name);
-
-    let realPath = '';
-
-    /**
-     * We're using a module here so we want to keep using the module resolution procedure.
-     */
-    if (info?.packageName || info?.required) {
-      /**
-       * path.join, on windows, it uses backslashes to resolve path.
-       * The problem is that Webpack does not windows paths
-       * With this tool, we need to rely on "/" and not "\".
-       * This is the reason why '..\\..\\..\\node_modules\\@strapi\\plugin-content-type-builder/strapi-admin.js' was not working.
-       * The regexp at line 105 aims to replace the windows backslashes by standard slash so that webpack can deal with them.
-       * Backslash looks to work only for absolute paths with webpack => https://webpack.js.org/concepts/module-resolution/#absolute-paths
-       */
-      realPath = path.join(pathToPlugin, 'strapi-admin').replace(/\\/g, '/');
-    } else {
-      realPath = path
-        .join(path.relative(path.resolve(dest, 'admin', 'src'), pathToPlugin), 'strapi-admin')
-        .replace(/\\/g, '/');
-    }
-
-    return {
-      name,
-      pathToPlugin: realPath,
-      shortName,
-    };
-  });
-
-  const content = `
-${pluginsArray
-  .map(({ pathToPlugin, shortName }) => {
-    const req = `'${pathToPlugin}'`;
-
-    return `import ${shortName} from ${req};`;
-  })
-  .join('\n')}
-
-
-const plugins = {
-${[...pluginsArray]
-  .map(({ name, shortName }) => {
-    return `  '${name}': ${shortName},`;
-  })
-  .join('\n')}
-};
-
-export default plugins;
-`;
-
-  return fs.writeFile(path.resolve(dest, 'admin', 'src', 'plugins.js'), content);
-}
-
 async function copyAdmin(dest) {
   const adminPath = getPkgPath('@strapi/admin');
 
@@ -86,49 +30,8 @@ async function createCacheDir({ appDir, plugins }) {
   );
 
   const pluginsWithFront = Object.entries(plugins)
-    .filter(([, plugin]) => {
-      /**
-       * There are two ways a plugin should be imported, either it's local to the strapi app,
-       * or it's an actual npm module that's installed and resolved via node_modules.
-       *
-       * We first check if the plugin is local to the strapi app, using a regular `resolve` because
-       * the pathToPlugin will be relative i.e. `/Users/my-name/strapi-app/src/plugins/my-plugin`.
-       *
-       * If the file doesn't exist well then it's probably a node_module, so instead we use `require.resolve`
-       * which will resolve the path to the module in node_modules. If it fails with the specific code `MODULE_NOT_FOUND`
-       * then it doesn't have an admin part to the package.
-       *
-       * NOTE: we should try to move to `./package.json[exports]` map with bundling of our own plugins,
-       * because these entry files are written in commonjs restricting features e.g. tree-shaking.
-       */
-      try {
-        const isLocalPluginWithLegacyAdminFile = fs.existsSync(
-          path.resolve(`${plugin.pathToPlugin}/strapi-admin.js`)
-        );
-
-        if (!isLocalPluginWithLegacyAdminFile) {
-          const isModulewithLegacyAdminFile = require.resolve(
-            `${plugin.pathToPlugin}/strapi-admin.js`
-          );
-
-          return isModulewithLegacyAdminFile;
-        }
-
-        return isLocalPluginWithLegacyAdminFile;
-      } catch (err) {
-        if (err.code === 'MODULE_NOT_FOUND') {
-          /**
-           * the plugin does not contain FE code, so we
-           * don't want to import it anyway
-           */
-          return false;
-        }
-
-        throw err;
-      }
-    })
-    .map(([name, plugin]) => ({ name, ...plugin }));
-
+    .map(([name, plugin]) => ({ name, ...plugin }))
+    .filter(filterPluginsByAdminEntry);
   // create .cache dir
   await fs.emptyDir(cacheDir);
 
@@ -166,7 +69,7 @@ async function createCacheDir({ appDir, plugins }) {
   }
 
   // create plugins.js with plugins requires
-  await createPluginsJs(pluginsWithFront, cacheDir);
+  await createPluginFile(pluginsWithFront, cacheDir);
 
   // create the tsconfig.json file so we can develop plugins in ts while being in a JS project
   if (!useTypeScript) {
@@ -174,4 +77,4 @@ async function createCacheDir({ appDir, plugins }) {
   }
 }
 
-module.exports = { createCacheDir, createPluginsJs };
+module.exports = { createCacheDir };

package/utils/plugins.js

@@ -0,0 +1,217 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const asyncFs = require('fs/promises');
+const { camelCase } = require('lodash');
+// eslint-disable-next-line import/no-extraneous-dependencies
+const glob = require('glob');
+
+/**
+ * @typedef {Object} PluginInfo
+ * @property {string} packageName
+ * @property {string} description
+ * @property {boolean=} required
+ */
+
+/**
+ * @typedef {Object} Plugin
+ * @property {string} pathToPlugin
+ * @property {string} name
+ * @property {PluginInfo} info
+ * @property {string=} directory
+ */
+
+/**
+ * @param {string[]} pluginsAllowlist
+ * @returns {Plugin[]}
+ */
+const getPlugins = (pluginsAllowlist) => {
+  const rootPath = path.resolve(__dirname, '..', path.join('..', '..', '..', 'packages'));
+  /**
+   * So `glob` only supports '/' as a path separator, so we need to replace
+   * the path separator for the current OS with '/'. e.g. on windows it's `\`.
+   *
+   * see https://github.com/isaacs/node-glob/#windows for more information
+   *
+   * and see https://github.com/isaacs/node-glob/issues/467#issuecomment-1114240501 for the recommended fix.
+   */
+  let corePath = path.join(rootPath, 'core', '*');
+  let pluginsPath = path.join(rootPath, 'plugins', '*');
+
+  if (process.platform === 'win32') {
+    corePath = corePath.split(path.sep).join(path.posix.sep);
+    pluginsPath = pluginsPath.split(path.sep).join(path.posix.sep);
+  }
+
+  const corePackageDirs = glob.sync(corePath);
+  const pluginsPackageDirs = glob.sync(pluginsPath);
+
+  const plugins = [...corePackageDirs, ...pluginsPackageDirs]
+    .map((directory) => {
+      const isCoreAdmin = directory.includes('packages/core/admin');
+
+      if (isCoreAdmin) {
+        return null;
+      }
+
+      const { name, strapi } = require(path.join(directory, 'package.json'));
+
+      /**
+       * this will remove any of our packages that are
+       * not actually plugins for the application
+       */
+      if (!strapi || strapi.kind !== 'plugin') {
+        return null;
+      }
+
+      /**
+       * we want the name of the node_module
+       */
+      return {
+        pathToPlugin: name,
+        name: strapi.name,
+        info: { ...strapi, packageName: name },
+        directory,
+      };
+    })
+    .filter(filterPluginsByAdminEntry);
+
+  if (Array.isArray(pluginsAllowlist)) {
+    return plugins.filter((plugin) => pluginsAllowlist.includes(plugin.pathToPlugin));
+  }
+
+  return plugins;
+};
+
+/**
+ * @type {(plugin: Plugin) => boolean}
+ */
+const filterPluginsByAdminEntry = (plugin) => {
+  if (!plugin) {
+    return false;
+  }
+
+  /**
+   * There are two ways a plugin should be imported, either it's local to the strapi app,
+   * or it's an actual npm module that's installed and resolved via node_modules.
+   *
+   * We first check if the plugin is local to the strapi app, using a regular `resolve` because
+   * the pathToPlugin will be relative i.e. `/Users/my-name/strapi-app/src/plugins/my-plugin`.
+   *
+   * If the file doesn't exist well then it's probably a node_module, so instead we use `require.resolve`
+   * which will resolve the path to the module in node_modules. If it fails with the specific code `MODULE_NOT_FOUND`
+   * then it doesn't have an admin part to the package.
+   *
+   * NOTE: we should try to move to `./package.json[exports]` map with bundling of our own plugins,
+   * because these entry files are written in commonjs restricting features e.g. tree-shaking.
+   */
+  try {
+    const isLocalPluginWithLegacyAdminFile = fs.existsSync(
+      path.resolve(`${plugin.pathToPlugin}/strapi-admin.js`)
+    );
+
+    if (!isLocalPluginWithLegacyAdminFile) {
+      const isModuleWithFE = require.resolve(`${plugin.pathToPlugin}/strapi-admin`);
+
+      return isModuleWithFE;
+    }
+
+    return isLocalPluginWithLegacyAdminFile;
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND') {
+      /**
+       * the plugin does not contain FE code, so we
+       * don't want to import it anyway
+       */
+      return false;
+    }
+
+    throw err;
+  }
+};
+
+/**
+ *
+ * @param {Plugin[]} plugins
+ * @param {string} dest
+ * @returns {void}
+ */
+async function createPluginFile(plugins, dest) {
+  const pluginsArray = plugins.map(({ pathToPlugin, name, info }) => {
+    const shortName = camelCase(name);
+
+    let realPath = '';
+
+    /**
+     * We're using a module here so we want to keep using the module resolution procedure.
+     */
+    if (info?.packageName || info?.required) {
+      /**
+       * path.join, on windows, it uses backslashes to resolve path.
+       * The problem is that Webpack does not windows paths
+       * With this tool, we need to rely on "/" and not "\".
+       * This is the reason why '..\\..\\..\\node_modules\\@strapi\\plugin-content-type-builder/strapi-admin.js' was not working.
+       * The regexp at line 105 aims to replace the windows backslashes by standard slash so that webpack can deal with them.
+       * Backslash looks to work only for absolute paths with webpack => https://webpack.js.org/concepts/module-resolution/#absolute-paths
+       */
+      realPath = path.join(pathToPlugin, 'strapi-admin').replace(/\\/g, '/');
+    } else {
+      realPath = path
+        .join(path.relative(path.resolve(dest, 'admin', 'src'), pathToPlugin), 'strapi-admin')
+        .replace(/\\/g, '/');
+    }
+
+    return {
+      name,
+      pathToPlugin: realPath,
+      shortName,
+    };
+  });
+
+  const content = `
+${pluginsArray
+  .map(({ pathToPlugin, shortName }) => {
+    const req = `'${pathToPlugin}'`;
+
+    return `import ${shortName} from ${req};`;
+  })
+  .join('\n')}
+
+
+const plugins = {
+${[...pluginsArray]
+  .map(({ name, shortName }) => {
+    return `  '${name}': ${shortName},`;
+  })
+  .join('\n')}
+};
+
+export default plugins;
+`;
+
+  return asyncFs.writeFile(path.resolve(dest, 'admin', 'src', 'plugins.js'), content);
+}
+
+/**
+ * @param {string[]} pluginsPath – an array of paths to the plugins from the user's directory
+ * @returns {RegExp} a regex that will exclude _all_ node_modules except for the plugins in the pluginsPath array.
+ */
+const createPluginsExcludePath = (pluginsPath = []) => {
+  /**
+   * If there aren't any plugins in the node_modules array, just return the node_modules regex
+   * without complicating it.
+   */
+  if (pluginsPath.length === 0) {
+    return /node_modules/;
+  }
+
+  return new RegExp(`node_modules/(?!(${pluginsPath.join('|')}))`);
+};
+
+module.exports = {
+  getPlugins,
+  filterPluginsByAdminEntry,
+  createPluginFile,
+  createPluginsExcludePath,
+};

package/webpack.config.js

@@ -13,7 +13,7 @@ const browserslistToEsbuild = require('browserslist-to-esbuild');
 
 const alias = require('./webpack.alias');
 const getClientEnvironment = require('./env');
-const { createPluginsExcludePath } = require('./utils/create-plugins-exclude-path');
+const { createPluginsExcludePath } = require('./utils/plugins');
 
 module.exports = ({
   dest,
@@ -85,7 +85,7 @@ module.exports = ({
     module: {
       rules: [
         {
-          test: /\.tsx?$/,
+          test: /\.(ts|tsx)$/,
           loader: require.resolve('esbuild-loader'),
           exclude: excludeRegex,
           options: {

package/build/1227.9f37e1dc.chunk.js

@@ -1 +0,0 @@
-"use strict";(self.webpackChunk_strapi_admin=self.webpackChunk_strapi_admin||[]).push([[1227],{21227:function(g,E,t){t.d(E,{ReviewWorkflowsAssigneeEE:function(){return O},ReviewWorkflowsStageEE:function(){return f}});var e=t(32735),s=t(87933),c=t(72850),i=t(49372),r=t(45509),l=t(60216),n=t.n(l),o=t(2121),u=t(68886);function f({color:a,name:A}){const{themeColorName:R}=(0,u.k)(a);return e.createElement(s.k,{alignItems:"center",gap:2,maxWidth:(0,r.Q1)(300)},e.createElement(c.x,{height:2,background:a,borderColor:R==="neutral0"?"neutral150":"transparent",hasRadius:!0,shrink:0,width:2}),e.createElement(i.Z,{fontWeight:"regular",textColor:"neutral700",ellipsis:!0},A))}f.defaultProps={color:o.FT},f.propTypes={color:n().string,name:n().string.isRequired};var T=t(67879),W=t(69997);function O({user:a}){const{formatMessage:A}=(0,T.Z)();return e.createElement(i.Z,{textColor:"neutral800"},(0,W.Gf)(a,A))}O.propTypes={user:n().shape({firstname:n().string,lastname:n().string,username:n().string}).isRequired}},2121:function(g,E,t){t.d(E,{$k:function(){return o},Ef:function(){return O},FT:function(){return T},Nj:function(){return n},Ot:function(){return l},VS:function(){return u},_X:function(){return a},gu:function(){return c},lv:function(){return f},qZ:function(){return i},sN:function(){return s},uL:function(){return W},x4:function(){return r}});var e=t(12301);const s="settings_review-workflows",c="Settings/Review_Workflows/RESET_WORKFLOW",i="Settings/Review_Workflows/SET_WORKFLOW",r="Settings/Review_Workflows/WORKFLOW_DELETE_STAGE",l="Settings/Review_Workflows/WORKFLOW_ADD_STAGE",n="Settings/Review_Workflows/WORKFLOW_UPDATE_STAGE",o="Settings/Review_Workflows/WORKFLOW_UPDATE_STAGE_POSITION",u="Settings/Review_Workflows/WORKFLOW_UPDATE",f={primary600:"Blue",primary200:"Lilac",alternative600:"Violet",alternative200:"Lavender",success600:"Green",success200:"Pale Green",danger500:"Cherry",danger200:"Pink",warning600:"Orange",warning200:"Yellow",secondary600:"Teal",secondary200:"Baby Blue",neutral400:"Gray",neutral0:"White"},T=e.W.colors.primary600,W={STAGE:"stage"},O="numberOfWorkflows",a="stagesPerWorkflow"},68886:function(g,E,t){t.d(E,{k:function(){return c},s:function(){return i}});var e=t(12301),s=t(2121);function c(r){if(!r)return null;const n=Object.entries(e.W.colors).filter(([,o])=>o.toUpperCase()===r.toUpperCase()).reduce((o,[u])=>(s.lv?.[u]&&(o=u),o),null);return n?{themeColorName:n,name:s.lv[n]}:null}function i(){return Object.entries(s.lv).map(([r,l])=>({hex:e.W.colors[r].toUpperCase(),name:l}))}}}]);