@strapi/strapi 4.10.0-beta.1 → 4.10.1-experimental.0

package/lib/commands/actions/transfer/__tests__/transfer.test.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const { expectExit } = require('../../../__tests__/commands.test.utils');
+
+describe('Transfer', () => {
+  // command utils
+  const mockUtils = {
+    getTransferTelemetryPayload: jest.fn().mockReturnValue({}),
+    loadersFactory: jest.fn().mockReturnValue({ updateLoader: jest.fn() }),
+    formatDiagnostic: jest.fn(),
+    createStrapiInstance() {
+      return {
+        telemetry: {
+          send: jest.fn(),
+        },
+      };
+    },
+    getDefaultExportName: jest.fn(() => 'default'),
+    buildTransferTable: jest.fn(() => {
+      return {
+        toString() {
+          return 'table';
+        },
+      };
+    }),
+    exitMessageText: jest.fn(),
+  };
+  jest.mock(
+    '../../../utils/data-transfer.js',
+    () => {
+      return mockUtils;
+    },
+    { virtual: true }
+  );
+
+  const mockDataTransfer = {
+    strapi: {
+      providers: {
+        createLocalStrapiSourceProvider: jest.fn().mockReturnValue({ name: 'testLocalSource' }),
+        createLocalStrapiDestinationProvider: jest
+          .fn()
+          .mockReturnValue({ name: 'testLocalDestination' }),
+        createRemoteStrapiDestinationProvider: jest
+          .fn()
+          .mockReturnValue({ name: 'testRemoteDest' }),
+      },
+    },
+    engine: {
+      ...jest.requireActual('@strapi/data-transfer').engine,
+      createTransferEngine() {
+        return {
+          transfer: jest.fn(() => {
+            return {
+              engine: {},
+            };
+          }),
+          progress: {
+            on: jest.fn(),
+            stream: {
+              on: jest.fn(),
+            },
+          },
+          sourceProvider: { name: 'testSource' },
+          destinationProvider: { name: 'testDestination' },
+          diagnostics: {
+            on: jest.fn().mockReturnThis(),
+            onDiagnostic: jest.fn().mockReturnThis(),
+          },
+        };
+      },
+    },
+  };
+
+  jest.mock('@strapi/data-transfer', () => mockDataTransfer);
+
+  const transferAction = require('../action');
+
+  // console spies
+  jest.spyOn(console, 'log').mockImplementation(() => {});
+  jest.spyOn(console, 'warn').mockImplementation(() => {});
+  jest.spyOn(console, 'info').mockImplementation(() => {});
+  jest.spyOn(console, 'error').mockImplementation(() => {});
+
+  const destinationUrl = new URL('http://one.localhost/admin');
+  const destinationToken = 'test-token';
+
+  const sourceUrl = new URL('http://two.localhost/admin');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('exits with error when no --to or --from is provided', async () => {
+    await expectExit(1, async () => {
+      await transferAction({ from: undefined, to: undefined });
+    });
+
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/one source/i));
+
+    expect(
+      mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
+    ).not.toHaveBeenCalled();
+  });
+
+  it('exits with error when both --to and --from are provided', async () => {
+    await expectExit(1, async () => {
+      await transferAction({ from: sourceUrl, to: destinationUrl });
+    });
+
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/one source/i));
+
+    expect(
+      mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
+    ).not.toHaveBeenCalled();
+  });
+
+  describe('--to', () => {
+    it('exits with error when auth is not provided', async () => {
+      await expectExit(1, async () => {
+        await transferAction({ from: undefined, to: destinationUrl });
+      });
+
+      expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/missing token/i));
+
+      expect(
+        mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
+      ).not.toHaveBeenCalled();
+    });
+
+    it('uses destination url and token provided by user', async () => {
+      await expectExit(0, async () => {
+        await transferAction({ from: undefined, to: destinationUrl, toToken: destinationToken });
+      });
+
+      expect(console.error).not.toHaveBeenCalled();
+      expect(
+        mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
+      ).toHaveBeenCalledWith(
+        expect.objectContaining({
+          url: destinationUrl,
+          auth: {
+            type: 'token',
+            token: destinationToken,
+          },
+        })
+      );
+    });
+
+    it('uses local Strapi source when from is not specified', async () => {
+      await expectExit(0, async () => {
+        await transferAction({ from: undefined, to: destinationUrl, toToken: destinationToken });
+      });
+
+      expect(console.error).not.toHaveBeenCalled();
+      expect(mockDataTransfer.strapi.providers.createLocalStrapiSourceProvider).toHaveBeenCalled();
+      expect(
+        mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
+      ).toHaveBeenCalled();
+    });
+  });
+
+  it.todo('uses local Strapi destination when to is not specified');
+
+  it('uses restore as the default strategy', async () => {
+    await expectExit(0, async () => {
+      await transferAction({ from: undefined, to: destinationUrl, toToken: destinationToken });
+    });
+
+    expect(console.error).not.toHaveBeenCalled();
+    expect(
+      mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
+    ).toHaveBeenCalledWith(
+      expect.objectContaining({
+        strategy: 'restore',
+      })
+    );
+  });
+});

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

@@ -22,8 +22,8 @@ const {
   exitMessageText,
   abortTransfer,
   getTransferTelemetryPayload,
-} = require('./utils');
-const { exitWith } = require('../utils/helpers');
+} = require('../../utils/data-transfer');
+const { exitWith } = require('../../utils/helpers');
 
 /**
  * @typedef TransferCommandOptions Options given to the CLI transfer command

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/{transfer/utils.js → utils/data-transfer.js}

@@ -12,9 +12,9 @@ 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, parseInteger } = require('../utils/commander');
+const { getParseListWithChoices, parseInteger } = require('./commander');
 
 const exitMessageText = (process, error = false) => {
   const processCapitalized = process[0].toUpperCase() + process.slice(1);

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,
 };