@strapi/strapi 4.10.0-beta.0 → 4.10.0

package/lib/commands/actions/transfer/command.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const inquirer = require('inquirer');
+const { Option } = require('commander');
+const { confirmMessage, forceOption, parseURL } = require('../../utils/commander');
+const {
+  getLocalScript,
+  exitWith,
+  assertUrlHasProtocol,
+  ifOptions,
+} = require('../../utils/helpers');
+const {
+  excludeOption,
+  onlyOption,
+  throttleOption,
+  validateExcludeOnly,
+} = require('../../utils/data-transfer');
+
+/**
+ * `$ strapi transfer`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('transfer')
+    .description('Transfer data from one source to another')
+    .allowExcessArguments(false)
+    .addOption(
+      new Option(
+        '--from <sourceURL>',
+        `URL of the remote Strapi instance to get data from`
+      ).argParser(parseURL)
+    )
+    .addOption(new Option('--from-token <token>', `Transfer token for the remote Strapi source`))
+    .addOption(
+      new Option(
+        '--to <destinationURL>',
+        `URL of the remote Strapi instance to send data to`
+      ).argParser(parseURL)
+    )
+    .addOption(new Option('--to-token <token>', `Transfer token for the remote Strapi destination`))
+    .addOption(forceOption)
+    .addOption(excludeOption)
+    .addOption(onlyOption)
+    .addOption(throttleOption)
+    .hook('preAction', validateExcludeOnly)
+    .hook(
+      'preAction',
+      ifOptions(
+        (opts) => !(opts.from || opts.to) || (opts.from && opts.to),
+        () =>
+          exitWith(
+            1,
+            'Exactly one remote source (from) or destination (to) option must be provided'
+          )
+      )
+    )
+    // If --from is used, validate the URL and token
+    .hook(
+      'preAction',
+      ifOptions(
+        (opts) => opts.from,
+        async (thisCommand) => {
+          assertUrlHasProtocol(thisCommand.opts().from, ['https:', 'http:']);
+          if (!thisCommand.opts().fromToken) {
+            const answers = await inquirer.prompt([
+              {
+                type: 'password',
+                message: 'Please enter your transfer token for the remote Strapi source',
+                name: 'fromToken',
+              },
+            ]);
+            if (!answers.fromToken?.length) {
+              exitWith(1, 'No token provided for remote source, aborting transfer.');
+            }
+            thisCommand.opts().fromToken = answers.fromToken;
+          }
+
+          await confirmMessage(
+            'The transfer will delete all the local Strapi assets and its database. Are you sure you want to proceed?',
+            { failMessage: 'Transfer process aborted' }
+          )(thisCommand);
+        }
+      )
+    )
+    // If --to is used, validate the URL, token, and confirm restore
+    .hook(
+      'preAction',
+      ifOptions(
+        (opts) => opts.to,
+        async (thisCommand) => {
+          assertUrlHasProtocol(thisCommand.opts().to, ['https:', 'http:']);
+          if (!thisCommand.opts().toToken) {
+            const answers = await inquirer.prompt([
+              {
+                type: 'password',
+                message: 'Please enter your transfer token for the remote Strapi destination',
+                name: 'toToken',
+              },
+            ]);
+            if (!answers.toToken?.length) {
+              exitWith(1, 'No token provided for remote destination, aborting transfer.');
+            }
+            thisCommand.opts().toToken = answers.toToken;
+          }
+
+          await confirmMessage(
+            'The transfer will delete all the remote Strapi assets and its database. Are you sure you want to proceed?',
+            { failMessage: 'Transfer process aborted' }
+          )(thisCommand);
+        }
+      )
+    )
+    .action(getLocalScript('transfer'));
+};

package/lib/commands/{ts/generate-types.js → actions/ts/generate-types/action.js}

@@ -2,9 +2,9 @@
 
 const tsUtils = require('@strapi/typescript-utils');
 
-const strapi = require('../../index');
+const strapi = require('../../../../index');
 
-module.exports = async function ({ outDir, file, verbose, silent }) {
+module.exports = async ({ outDir, file, verbose, silent }) => {
   if (verbose && silent) {
     console.error('You cannot enable verbose and silent flags at the same time, exiting...');
     process.exit(1);

package/lib/commands/actions/ts/generate-types/command.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi ts:generate-types`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('ts:generate-types')
+    .description(`Generate TypeScript typings for your schemas`)
+    .option(
+      '-o, --out-dir <outDir>',
+      'Specify a relative directory in which the schemas definitions will be generated'
+    )
+    .option('-f, --file <file>', 'Specify a filename to store the schemas definitions')
+    .option('--verbose', `Display more information about the types generation`, false)
+    .option('-s, --silent', `Run the generation silently, without any output`, false)
+    .action(getLocalScript('ts/generate-types'));
+};

package/lib/commands/{uninstall.js → actions/uninstall/action.js}

@@ -5,7 +5,7 @@ const { existsSync, removeSync } = require('fs-extra');
 const ora = require('ora');
 const execa = require('execa');
 const inquirer = require('inquirer');
-const findPackagePath = require('../load/package-path');
+const findPackagePath = require('../../../load/package-path');
 
 module.exports = async (plugins, { deleteFiles }) => {
   const answers = await inquirer.prompt([

package/lib/commands/actions/uninstall/command.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { getLocalScript } = require('../../utils/helpers');
+
+/**
+ * `$ strapi uninstall`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('uninstall [plugins...]')
+    .description('Uninstall a Strapi plugin')
+    .option('-d, --delete-files', 'Delete files', false)
+    .action(getLocalScript('uninstall'));
+};

package/lib/commands/actions/version/command.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * `$ strapi version`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  // load the Strapi package.json to get version and other information
+  const packageJSON = require('../../../../package.json');
+
+  command.version(packageJSON.version, '-v, --version', 'Output the version number');
+  command
+    .command('version')
+    .description('Output the version of Strapi')
+    .action(() => {
+      process.stdout.write(`${packageJSON.version}\n`);
+      process.exit(0);
+    });
+};

package/lib/commands/{watchAdmin.js → actions/watch-admin/action.js}

@@ -3,11 +3,11 @@
 const strapiAdmin = require('@strapi/admin');
 const { getConfigUrls, getAbsoluteServerUrl } = require('@strapi/utils');
 
-const getEnabledPlugins = require('../core/loaders/plugins/get-enabled-plugins');
-const addSlash = require('../utils/addSlash');
-const strapi = require('../index');
+const getEnabledPlugins = require('../../../core/loaders/plugins/get-enabled-plugins');
+const addSlash = require('../../../utils/addSlash');
+const strapi = require('../../../index');
 
-module.exports = async function ({ browser }) {
+module.exports = async ({ browser }) => {
   const appContext = await strapi.compile();
 
   const strapiInstance = strapi({

package/lib/commands/actions/watch-admin/command.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { getLocalScript } = require('../../utils/helpers');
+
+/**
+ * `$ strapi watch-admin`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('watch-admin')
+    .option('--browser <name>', 'Open the browser', true)
+    .description('Start the admin development server')
+    .action(getLocalScript('watch-admin'));
+};

package/lib/commands/index.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const { Command } = require('commander');
+
+const strapiCommands = {
+  'admin/create-user': require('./actions/admin/create-user/command'),
+  'admin/reset-user-password': require('./actions/admin/reset-user-password/command'),
+  build: require('./actions/build/command'),
+  'configuration/dump': require('./actions/configuration/dump/command'),
+  'configuration/restore': require('./actions/configuration/restore/command'),
+  console: require('./actions/console/command'),
+  'content-types/list': require('./actions/content-types/list/command'),
+  'controllers/list': require('./actions/controllers/list/command'),
+  develop: require('./actions/develop/command'),
+  export: require('./actions/export/command'),
+  generate: require('./actions/generate/command'),
+  'hooks/list': require('./actions/hooks/list/command'),
+  import: require('./actions/import/command'),
+  install: require('./actions/install/command'),
+  'middlewares/list': require('./actions/middlewares/list/command'),
+  new: require('./actions/new/command'),
+  'policies/list': require('./actions/policies/list/command'),
+  report: require('./actions/report/command'),
+  'routes/list': require('./actions/routes/list/command'),
+  'services/list': require('./actions/services/list/command'),
+  start: require('./actions/start/command'),
+  'telemetry/disable': require('./actions/telemetry/disable/command'),
+  'telemetry/enable': require('./actions/telemetry/enable/command'),
+  'templates/generate': require('./actions/templates/generate/command'),
+  transfer: require('./actions/transfer/command'),
+  'ts/generate-types': require('./actions/ts/generate-types/command'),
+  uninstall: require('./actions/uninstall/command'),
+  version: require('./actions/version/command'),
+  'watch-admin': require('./actions/watch-admin/command'),
+};
+
+const buildStrapiCommand = (argv, command = new Command()) => {
+  // Initial program setup
+  command.storeOptionsAsProperties(false).allowUnknownOption(true);
+
+  // Help command
+  command.helpOption('-h, --help', 'Display help for command');
+  command.addHelpCommand('help [command]', 'Display help for command');
+
+  // Load all commands
+  Object.keys(strapiCommands).forEach((name) => {
+    try {
+      // Add this command to the Commander command object
+      strapiCommands[name]({ command, argv });
+    } catch (e) {
+      console.error(`Failed to load command ${name}`, e);
+    }
+  });
+
+  return command;
+};
+
+const runStrapiCommand = async (argv = process.argv, command = new Command()) => {
+  await buildStrapiCommand(argv, command).parseAsync(argv);
+};
+
+module.exports = {
+  runStrapiCommand,
+  buildStrapiCommand,
+  strapiCommands,
+};

package/lib/commands/utils/commander.js

@@ -7,6 +7,7 @@
 const inquirer = require('inquirer');
 const { InvalidOptionArgumentError, Option } = require('commander');
 const { bold, green, cyan } = require('chalk');
+const { isNaN } = require('lodash/fp');
 const { exitWith } = require('./helpers');
 
 /**
@@ -40,6 +41,18 @@ const getParseListWithChoices = (choices, errorMessage = 'Invalid options:') =>
   };
 };
 
+/**
+ * argParser: Parse a string as an integer
+ */
+const parseInteger = (value) => {
+  // parseInt takes a string and a radix
+  const parsedValue = parseInt(value, 10);
+  if (isNaN(parsedValue)) {
+    throw new InvalidOptionArgumentError(`Not an integer: ${value}`);
+  }
+  return parsedValue;
+};
+
 /**
  * argParser: Parse a string as a URL object
  */
@@ -131,6 +144,7 @@ module.exports = {
   getParseListWithChoices,
   parseList,
   parseURL,
+  parseInteger,
   promptEncryptionKey,
   confirmMessage,
   forceOption,

package/lib/commands/{transfer/utils.js → utils/data-transfer.js}

@@ -12,9 +12,21 @@ const {
   createLogger,
 } = require('@strapi/logger');
 const ora = require('ora');
-const { readableBytes, exitWith } = require('../utils/helpers');
+const { readableBytes, exitWith } = require('./helpers');
 const strapi = require('../../index');
-const { getParseListWithChoices } = require('../utils/commander');
+const { getParseListWithChoices, parseInteger } = require('./commander');
+
+const exitMessageText = (process, error = false) => {
+  const processCapitalized = process[0].toUpperCase() + process.slice(1);
+
+  if (!error) {
+    return chalk.bold(
+      chalk.green(`${processCapitalized} process has been completed successfully!`)
+    );
+  }
+
+  return chalk.bold(chalk.red(`${processCapitalized} process failed.`));
+};
 
 const pad = (n) => {
   return (n < 10 ? '0' : '') + String(n);
@@ -90,12 +102,23 @@ const DEFAULT_IGNORED_CONTENT_TYPES = [
   'admin::audit-log',
 ];
 
-const createStrapiInstance = async (logLevel = 'error') => {
+const abortTransfer = async ({ engine, strapi }) => {
+  try {
+    await engine.abortTransfer();
+    await strapi.destroy();
+  } catch (e) {
+    // ignore because there's not much else we can do
+    return false;
+  }
+  return true;
+};
+
+const createStrapiInstance = async (opts = {}) => {
   try {
     const appContext = await strapi.compile();
-    const app = strapi(appContext);
+    const app = strapi({ ...opts, ...appContext });
 
-    app.log.level = logLevel;
+    app.log.level = opts.logLevel || 'error';
     return await app.load();
   } catch (err) {
     if (err.code === 'ECONNREFUSED') {
@@ -107,6 +130,13 @@ const createStrapiInstance = async (logLevel = 'error') => {
 
 const transferDataTypes = Object.keys(TransferGroupPresets);
 
+const throttleOption = new Option(
+  '--throttle <delay after each entity>',
+  `Add a delay in milliseconds between each transferred entity`
+)
+  .argParser(parseInteger)
+  .hideHelp(); // This option is not publicly documented
+
 const excludeOption = new Option(
   '--exclude <comma-separated data types>',
   `Exclude data using comma-separated types. Available types: ${transferDataTypes.join(',')}`
@@ -212,14 +242,33 @@ const loadersFactory = (defaultLoaders = {}) => {
   };
 };
 
+/**
+ * Get the telemetry data to be sent for a didDEITSProcess* event from an initialized transfer engine object
+ *
+ * @param {import('@strapi/data-transfer/types').ITransferEngine} engine Initialized transfer engine
+ * @returns {object} Telemetry properties object
+ */
+const getTransferTelemetryPayload = (engine) => {
+  return {
+    eventProperties: {
+      source: engine?.sourceProvider?.name,
+      destination: engine?.destinationProvider?.name,
+    },
+  };
+};
+
 module.exports = {
   loadersFactory,
   buildTransferTable,
   getDefaultExportName,
+  getTransferTelemetryPayload,
   DEFAULT_IGNORED_CONTENT_TYPES,
   createStrapiInstance,
   excludeOption,
+  exitMessageText,
   onlyOption,
+  throttleOption,
   validateExcludeOnly,
   formatDiagnostic,
+  abortTransfer,
 };

package/lib/commands/utils/helpers.js

@@ -4,8 +4,10 @@
  * Helper functions for the Strapi CLI
  */
 
-const chalk = require('chalk');
+const { yellow, red, green } = require('chalk');
 const { isString, isArray } = require('lodash/fp');
+const resolveCwd = require('resolve-cwd');
+const { has } = require('lodash/fp');
 
 const bytesPerKb = 1024;
 const sizes = ['B ', 'KB', 'MB', 'GB', 'TB', 'PB'];
@@ -46,9 +48,9 @@ const exitWith = (code, message = undefined, options = {}) => {
 
   const log = (message) => {
     if (code === 0) {
-      logger.log(chalk.green(message));
+      logger.log(green(message));
     } else {
-      logger.error(chalk.red(message));
+      logger.error(red(message));
     }
   };
 
@@ -107,9 +109,58 @@ const ifOptions = (conditionCallback, isMetCallback = () => {}, isNotMetCallback
   };
 };
 
+const assertCwdContainsStrapiProject = (name) => {
+  const logErrorAndExit = () => {
+    console.log(
+      `You need to run ${yellow(
+        `strapi ${name}`
+      )} in a Strapi project. Make sure you are in the right directory.`
+    );
+    process.exit(1);
+  };
+
+  try {
+    const pkgJSON = require(`${process.cwd()}/package.json`);
+    if (!has('dependencies.@strapi/strapi', pkgJSON)) {
+      logErrorAndExit(name);
+    }
+  } catch (err) {
+    logErrorAndExit(name);
+  }
+};
+
+const getLocalScript =
+  (name) =>
+  (...args) => {
+    assertCwdContainsStrapiProject(name);
+
+    const cmdPath = resolveCwd.silent(`@strapi/strapi/lib/commands/actions/${name}/action`);
+    if (!cmdPath) {
+      console.log(
+        `Error loading the local ${yellow(
+          name
+        )} command. Strapi might not be installed in your "node_modules". You may need to run "yarn install".`
+      );
+      process.exit(1);
+    }
+
+    const script = require(cmdPath);
+
+    Promise.resolve()
+      .then(() => {
+        return script(...args);
+      })
+      .catch((error) => {
+        console.error(error);
+        process.exit(1);
+      });
+  };
+
 module.exports = {
   exitWith,
   assertUrlHasProtocol,
   ifOptions,
   readableBytes,
+  getLocalScript,
+  assertCwdContainsStrapiProject,
 };

package/lib/core/domain/content-type/validator.js

@@ -61,7 +61,7 @@ const contentTypeSchemaValidator = yup.object().shape({
 
             // should match the GraphQL regex
             if (!regressedValues.every((value) => GRAPHQL_ENUM_REGEX.test(value))) {
-              const message = `Invalid enumeration value. Values should have at least one alphabetical character preceeding the first occurence of a number. Update your enumeration '${attrName}'.`;
+              const message = `Invalid enumeration value. Values should have at least one alphabetical character preceding the first occurence of a number. Update your enumeration '${attrName}'.`;
 
               return this.createError({ message });
             }

package/lib/core/loaders/plugins/index.js

@@ -2,7 +2,7 @@
 
 const { join } = require('path');
 const fse = require('fs-extra');
-const { defaultsDeep, getOr, get } = require('lodash/fp');
+const { defaultsDeep, defaults, getOr, get } = require('lodash/fp');
 const { env } = require('@strapi/utils');
 const loadConfigFile = require('../../app-configuration/load-config-file');
 const loadFiles = require('../../../load/load-files');
@@ -101,7 +101,12 @@ const loadPlugins = async (strapi) => {
     }
 
     const pluginServer = loadConfigFile(serverEntrypointPath);
-    plugins[pluginName] = defaultsDeep(defaultPlugin, pluginServer);
+    plugins[pluginName] = {
+      ...defaultPlugin,
+      ...pluginServer,
+      config: defaults(defaultPlugin.config, pluginServer.config),
+      routes: pluginServer.routes ?? defaultPlugin.routes,
+    };
   }
 
   // TODO: validate plugin format

package/lib/core/registries/custom-fields.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { has } = require('lodash/fp');
+const { has, isPlainObject } = require('lodash/fp');
 
 const ALLOWED_TYPES = [
   'biginteger',
@@ -44,7 +44,7 @@ const customFieldsRegistry = (strapi) => {
           throw new Error(`Custom fields require a 'name' and 'type' key`);
         }
 
-        const { name, plugin, type } = cf;
+        const { name, plugin, type, inputSize } = cf;
         if (!ALLOWED_TYPES.includes(type)) {
           throw new Error(
             `Custom field type: '${type}' is not a valid Strapi type or it can't be used with a Custom Field`
@@ -56,6 +56,23 @@ const customFieldsRegistry = (strapi) => {
           throw new Error(`Custom field name: '${name}' is not a valid object key`);
         }
 
+        // Validate inputSize when provided
+        if (inputSize) {
+          if (
+            !isPlainObject(inputSize) ||
+            !has('default', inputSize) ||
+            !has('isResizable', inputSize)
+          ) {
+            throw new Error(`inputSize should be an object with 'default' and 'isResizable' keys`);
+          }
+          if (![4, 6, 8, 12].includes(inputSize.default)) {
+            throw new Error('Custom fields require a valid default input size');
+          }
+          if (typeof inputSize.isResizable !== 'boolean') {
+            throw new Error('Custom fields should specify if their input is resizable');
+          }
+        }
+
         // When no plugin is specified, or it isn't found in Strapi, default to global
         const uid = strapi.plugin(plugin) ? `plugin::${plugin}.${name}` : `global::${name}`;
 

package/lib/core/registries/policies.d.ts

@@ -1,9 +1,9 @@
-import { BaseContext } from 'koa';
+import { ExtendableContext } from 'koa';
 import { Strapi } from '../../';
 
-interface PolicyContext extends BaseContext {
+interface PolicyContext extends ExtendableContext {
   type: string;
-  is(name): boolean;
+  is(name: string): boolean;
 }
 
 export type Policy<T = unknown> = (

package/lib/core-api/controller/collection-type.js

@@ -22,7 +22,6 @@ const createCollectionTypeController = ({ contentType }) => {
       const sanitizedQuery = await this.sanitizeQuery(ctx);
       const { results, pagination } = await strapi.service(uid).find(sanitizedQuery);
       const sanitizedResults = await this.sanitizeOutput(results, ctx);
-
       return this.transformResponse(sanitizedResults, { pagination });
     },
 

package/lib/core-api/controller/index.js

@@ -18,7 +18,7 @@ const createController = ({ contentType }) => {
       return transformResponse(data, meta, { contentType });
     },
 
-    sanitizeOutput(data, ctx) {
+    async sanitizeOutput(data, ctx) {
       const auth = getAuthFromKoaContext(ctx);
 
       return sanitize.contentAPI.output(data, contentType, { auth });

package/lib/factories.js

@@ -45,13 +45,12 @@ const createCoreService = (uid, cfg = {}) => {
 };
 
 const createCoreRouter = (uid, cfg = {}) => {
-  const { prefix, config = {}, only, except } = cfg;
+  const { prefix, config = {}, only, except, type } = cfg;
   let routes;
 
   return {
-    get prefix() {
-      return prefix;
-    },
+    type,
+    prefix,
     get routes() {
       if (!routes) {
         const contentType = strapi.contentType(uid);

package/lib/middlewares/logger.js

@@ -1,21 +1,5 @@
 'use strict';
 
-/* eslint-disable no-nested-ternary */
-
-const chalk = require('chalk');
-
-const codeToColor = (code) => {
-  return code >= 500
-    ? chalk.red(code)
-    : code >= 400
-    ? chalk.yellow(code)
-    : code >= 300
-    ? chalk.cyan(code)
-    : code >= 200
-    ? chalk.green(code)
-    : code;
-};
-
 /**
  * @type {import('./').MiddlewareFactory}
  */
@@ -25,6 +9,6 @@ module.exports = (_, { strapi }) => {
     await next();
     const delta = Math.ceil(Date.now() - start);
 
-    strapi.log.http(`${ctx.method} ${ctx.url} (${delta} ms) ${codeToColor(ctx.status)}`);
+    strapi.log.http(`${ctx.method} ${ctx.url} (${delta} ms) ${ctx.status}`);
   };
 };