@strapi/admin 4.15.0 → 4.15.2

package/scripts/build.js

@@ -1,122 +0,0 @@
-'use strict';
-
-const path = require('path');
-const webpack = require('webpack');
-const { isObject } = require('lodash');
-// eslint-disable-next-line import/no-extraneous-dependencies
-const SpeedMeasurePlugin = require('speed-measure-webpack-plugin');
-
-const webpackConfig = require('../webpack.config');
-const { getPlugins, createPluginFile } = require('../utils/plugins');
-
-// Wrapper that outputs the webpack speed
-const smp = new SpeedMeasurePlugin();
-
-const buildAdmin = async () => {
-  const entry = path.join(__dirname, '..', 'admin', 'src');
-  const dest = path.join(__dirname, '..', 'build');
-  const tsConfigFilePath = path.join(__dirname, '..', 'admin', 'tsconfig.build.json');
-
-  /**
-   * We _always_ install these FE plugins, they're considered "core"
-   * and are typically marked as `required` in their package.json
-   */
-  const plugins = getPlugins([
-    '@strapi/plugin-content-type-builder',
-    '@strapi/plugin-email',
-    '@strapi/plugin-upload',
-    '@strapi/plugin-i18n',
-    '@strapi/plugin-users-permissions',
-  ]);
-
-  await createPluginFile(plugins, path.join(__dirname, '..'));
-
-  const args = {
-    entry,
-    dest,
-    plugins,
-    env: 'production',
-    optimize: true,
-    options: {
-      backend: 'http://localhost:1337',
-      adminPath: '/admin/',
-
-      /**
-       * Ideally this would take more scenarios into account, such
-       * as the `telemetryDisabled` property in the package.json
-       * of the users project. For builds based on an app we are
-       * passing this information throgh, but here we do not have access
-       * to the app's package.json. By using at least an environment variable
-       * we can make sure developers can actually test this functionality.
-       */
-
-      telemetryDisabled: process.env.STRAPI_TELEMETRY_DISABLED === 'true' ?? false,
-    },
-    tsConfigFilePath,
-    enforceSourceMaps: process.env.STRAPI_ENFORCE_SOURCEMAPS === 'true' ?? false,
-  };
-
-  const config =
-    process.env.MEASURE_BUILD_SPEED === 'true'
-      ? smp.wrap(webpackConfig(args))
-      : webpackConfig(args);
-
-  const compiler = webpack(config);
-
-  console.log('Building the admin panel');
-
-  return new Promise((resolve, reject) => {
-    compiler.run((err, stats) => {
-      let messages;
-      if (err) {
-        if (!err.message) {
-          return reject(err);
-        }
-        messages = {
-          errors: [err.message],
-          warnings: [],
-        };
-      } else {
-        messages = stats.toJson({ all: false, warnings: true, errors: true });
-      }
-
-      if (messages.errors.length) {
-        // Only keep the first error. Others are often indicative
-        // of the same problem, but confuse the reader with noise.
-        if (messages.errors.length > 1) {
-          messages.errors.length = 1;
-        }
-
-        return reject(
-          new Error(
-            messages.errors.reduce((acc, error) => {
-              if (isObject(error)) {
-                return acc + error.message;
-              }
-
-              if (Array.isArray(error)) {
-                return acc + error.join('\n\n');
-              }
-
-              return acc + error;
-            }, '')
-          )
-        );
-      }
-
-      return resolve({
-        stats,
-        warnings: messages.warnings,
-      });
-    });
-  });
-};
-
-buildAdmin()
-  .then(() => {
-    process.exit();
-  })
-  .catch((err) => {
-    console.error(err);
-    process.exit(1);
-  });

package/scripts/create-dev-plugins-file.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const { join } = require('path');
-const fs = require('fs-extra');
-const { getPlugins, createPluginFile } = require('../utils/plugins');
-
-/**
- * Write the plugins.js file or copy the plugins-dev.js file if it exists
- */
-const createFile = async () => {
-  const customPluginFile = join(__dirname, '..', 'admin', 'src', 'plugins-dev.js');
-  const pluginFileDest = join(__dirname, '..', 'admin', 'src', 'plugins.js');
-
-  if (fs.existsSync(customPluginFile)) {
-    await fs.copy(customPluginFile, pluginFileDest);
-
-    return;
-  }
-
-  const plugins = getPlugins();
-
-  return createPluginFile(plugins, join(__dirname, '..'));
-};
-
-createFile()
-  .then(() => {
-    console.log('plugins.js file created');
-    process.exit();
-  })
-  .catch((err) => {
-    console.error(err);
-    process.exit(1);
-  });

package/shared/entities.ts

@@ -1,33 +0,0 @@
-import type { Entity as TEntity } from '@strapi/types';
-
-export interface Entity {
-  id: TEntity.ID;
-  createdAt: string;
-  updatedAt: string;
-}
-
-/**
- * TODO: is there a way to infer this from the content-type schema?
- * TODO: define content-type schema for a role.
- */
-export interface RoleEntity extends Entity {
-  name: string;
-  code: string;
-  description?: string;
-  usersCount?: number;
-}
-
-/**
- * TODO: is there a way to infer this from the content-type schema?
- * TODO: define content-type schema for a user.
- */
-export interface UserEntity extends Entity {
-  firstname: string;
-  lastname?: string;
-  username?: null | string;
-  email: string;
-  isActive: boolean;
-  blocked: boolean;
-  preferedLanguage: null | string;
-  roles: RoleEntity[];
-}

package/shared/permissions.ts

@@ -1,52 +0,0 @@
-type Condition = {
-  id: string;
-  displayName: string;
-  category: string;
-};
-
-type Permission = {
-  action: string;
-  displayName: string;
-  plugin: string;
-  subCategory: string;
-};
-
-type ContentTypePermission = {
-  actionId: string;
-  applyToProperties: string[];
-  label: string;
-  subjects: string[];
-};
-
-type ContentTypeSubject = {
-  uid: string;
-  label: string;
-  properties: ContentTypeSubjectProperties[];
-};
-
-type ContentTypeSubjectPropertyChild = {
-  label: string;
-  value: string;
-  required?: boolean;
-};
-
-type ContentTypeSubjectProperties = {
-  label: string;
-  value: string;
-  children: ContentTypeSubjectPropertyChild[];
-};
-
-type ContentTypePermissions = {
-  actions: ContentTypePermission[];
-  subjects: ContentTypeSubject[];
-};
-
-export interface RolePermissions {
-  conditions: Condition[];
-  sections: {
-    plugins: Permission[];
-    settings: Permission[];
-    singleTypes: ContentTypePermissions;
-    collectionTypes: ContentTypePermissions;
-  };
-}

package/shared/schema.ts

@@ -1,9 +0,0 @@
-import { Schema } from '@strapi/types';
-
-export interface ContentType extends Schema.ContentType {
-    isDisplayed: boolean;
-}
-
-export interface Component extends Schema.Component {
-    isDisplayed: boolean;
-}

package/utils/create-cache-dir.js

@@ -1,80 +0,0 @@
-'use strict';
-
-const path = require('path');
-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 copyAdmin(dest) {
-  const adminPath = getPkgPath('@strapi/admin');
-
-  // TODO copy ee folders for plugins
-  await fs.copy(path.resolve(adminPath, 'ee', 'admin'), path.resolve(dest, 'ee', 'admin'));
-
-  await fs.ensureDir(path.resolve(dest, 'config'));
-  await fs.copy(path.resolve(adminPath, 'admin'), path.resolve(dest, 'admin'));
-
-  // Copy package.json
-  await fs.copy(path.resolve(adminPath, 'package.json'), path.resolve(dest, 'package.json'));
-}
-
-async function createCacheDir({ appDir, plugins }) {
-  const cacheDir = path.resolve(appDir, '.cache');
-
-  const useTypeScript = await tsUtils.isUsingTypeScript(
-    path.join(appDir, 'src', 'admin'),
-    'tsconfig.json'
-  );
-
-  const pluginsWithFront = Object.entries(plugins)
-    .map(([name, plugin]) => ({ name, ...plugin }))
-    .filter(filterPluginsByAdminEntry);
-  // create .cache dir
-  await fs.emptyDir(cacheDir);
-
-  // copy admin core code
-  await copyAdmin(cacheDir);
-
-  // Retrieve the custom config file extension
-  const customAdminAppConfigFile = await getCustomAppConfigFile(appDir, useTypeScript);
-
-  if (customAdminAppConfigFile) {
-    const defaultAdminConfigFilePath = path.resolve(cacheDir, 'admin', 'src', 'app.js');
-    const customAdminAppConfigFilePath = path.join(
-      appDir,
-      'src',
-      'admin',
-      customAdminAppConfigFile
-    );
-    const dest = path.resolve(cacheDir, 'admin', 'src', customAdminAppConfigFile);
-
-    if (useTypeScript) {
-      // Remove the default config file
-      await fs.remove(defaultAdminConfigFilePath);
-      // Copy the custom one
-      await fs.copy(customAdminAppConfigFilePath, dest);
-    } else {
-      await fs.copy(customAdminAppConfigFilePath, dest);
-    }
-  }
-
-  // Copy admin extensions folder
-  const adminExtensionFolder = path.join(appDir, 'src', 'admin', 'extensions');
-
-  if (fs.existsSync(adminExtensionFolder)) {
-    await fs.copy(adminExtensionFolder, path.resolve(cacheDir, 'admin', 'src', 'extensions'));
-  }
-
-  // create plugins.js with plugins requires
-  await createPluginFile(pluginsWithFront, cacheDir);
-
-  // create the tsconfig.json file so we can develop plugins in ts while being in a JS project
-  if (!useTypeScript) {
-    await tsUtils.admin.createTSConfigFile(cacheDir);
-  }
-}
-
-module.exports = { createCacheDir };

package/utils/get-custom-app-config-file.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const { join } = require('path');
-const fse = require('fs-extra');
-const { isUsingTypeScript } = require('@strapi/typescript-utils');
-
-/**
- * Retrieve the custom admin entry file name
- * @param {String} dir - Directory of the admin panel
- * @returns String
- */
-const getCustomAppConfigFile = async (dir) => {
-  const adminSrcPath = join(dir, 'src', 'admin');
-
-  if (!fse.pathExistsSync(adminSrcPath)) {
-    return undefined;
-  }
-
-  const useTypeScript = await isUsingTypeScript(adminSrcPath, 'tsconfig.json');
-
-  const files = await fse.readdir(adminSrcPath);
-
-  const appJsx = files.find((file) => /^app.jsx?$/.test(file));
-  const appTsx = files.find((file) => /^app.tsx?$/.test(file));
-
-  if (useTypeScript) {
-    return appTsx || appJsx;
-  }
-
-  return appJsx;
-};
-
-module.exports = getCustomAppConfigFile;

package/utils/get-custom-webpack-config.js

@@ -1,38 +0,0 @@
-'use strict';
-
-const path = require('path');
-const chalk = require('chalk');
-const _ = require('lodash');
-const webpack = require('webpack');
-const fs = require('fs-extra');
-const getWebpackConfig = require('../webpack.config');
-
-const getCustomWebpackConfig = (dir, config) => {
-  const adminConfigPath = path.join(dir, 'src', 'admin', 'webpack.config.js');
-
-  let webpackConfig = getWebpackConfig(config);
-
-  if (fs.existsSync(adminConfigPath)) {
-    const webpackAdminConfig = require(path.resolve(adminConfigPath));
-
-    if (_.isFunction(webpackAdminConfig)) {
-      // Expose the devServer configuration
-      if (config.devServer) {
-        webpackConfig.devServer = config.devServer;
-      }
-
-      webpackConfig = webpackAdminConfig(webpackConfig, webpack);
-
-      if (!webpackConfig) {
-        console.error(
-          `${chalk.red('Error:')} Nothing was returned from your custom webpack configuration`
-        );
-        process.exit(1);
-      }
-    }
-  }
-
-  return webpackConfig;
-};
-
-module.exports = getCustomWebpackConfig;

package/utils/index.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const { createCacheDir } = require('./create-cache-dir');
-const getCustomWebpackConfig = require('./get-custom-webpack-config');
-const shouldBuildAdmin = require('./should-build-admin');
-const watchAdminFiles = require('./watch-admin-files');
-
-module.exports = {
-  createCacheDir,
-  getCustomWebpackConfig,
-  shouldBuildAdmin,
-  watchAdminFiles,
-};

package/utils/plugins.js

@@ -1,223 +0,0 @@
-'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) {
-      let pathToPlugin = plugin.pathToPlugin;
-
-      if (process.platform === 'win32') {
-        pathToPlugin = pathToPlugin.split(path.sep).join(path.posix.sep);
-      }
-
-      const isModuleWithFE = require.resolve(`${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/utils/should-build-admin.js

@@ -1,52 +0,0 @@
-'use strict';
-
-const path = require('path');
-const fs = require('fs-extra');
-const getCustomAppConfigFile = require('./get-custom-app-config-file');
-
-const DEFAULT_PLUGINS = [
-  'content-type-builder',
-  'content-manager',
-  'upload',
-  'email',
-  'i18n',
-  'users-permissions',
-];
-
-/**
- * Checks if the project's installed plugins are not the same as a default one.
- * @param {Object} plugins
- * @returns {boolean}
- */
-const hasNonDefaultPlugins = (plugins) => {
-  // List of plugins that are not the ones installed in a generated app
-  const installedPlugins = Object.keys(plugins).filter((x) => !DEFAULT_PLUGINS.includes(x));
-
-  // List of default plugins uninstalled from a generated app
-  const missingPlugins = DEFAULT_PLUGINS.filter((x) => !Object.keys(plugins).includes(x));
-
-  const diff = [...installedPlugins, ...missingPlugins];
-
-  return diff.length > 0;
-};
-
-const hasCustomAdminCode = async (dir) => {
-  const customAdminPath = path.join(dir, 'src', 'admin');
-
-  const customAdminAppConfigFile = await getCustomAppConfigFile(dir);
-  const customAdminWebpackFile = path.join(customAdminPath, 'webpack.config.js');
-
-  const hasCustomConfigFile = !!customAdminAppConfigFile;
-  const hasCustomWebpackFile = await fs.pathExists(customAdminWebpackFile);
-
-  return hasCustomConfigFile || hasCustomWebpackFile;
-};
-
-const shouldBuildAdmin = async ({ appDir, plugins }) => {
-  const appHasCustomAdminCode = await hasCustomAdminCode(appDir);
-  const appHasNonDefaultPlugins = hasNonDefaultPlugins(plugins);
-
-  return appHasCustomAdminCode || appHasNonDefaultPlugins;
-};
-
-module.exports = shouldBuildAdmin;