@strapi/strapi 4.9.0-alpha.0 → 4.9.0-beta.1

package/bin/strapi.js

@@ -18,18 +18,16 @@ const {
   promptEncryptionKey,
   confirmMessage,
   forceOption,
+  parseURL,
 } = require('../lib/commands/utils/commander');
-const { exitWith } = require('../lib/commands/utils/helpers');
+const { exitWith, ifOptions, assertUrlHasProtocol } = require('../lib/commands/utils/helpers');
 const {
   excludeOption,
   onlyOption,
+  throttleOption,
   validateExcludeOnly,
 } = require('../lib/commands/transfer/utils');
 
-process.on('SIGINT', () => {
-  process.exit();
-});
-
 const checkCwdIsStrapiApp = (name) => {
   const logErrorAndExit = () => {
     console.log(
@@ -272,59 +270,90 @@ program
   .option('-s, --silent', `Run the generation silently, without any output`, false)
   .action(getLocalScript('ts/generate-types'));
 
-// if (process.env.STRAPI_EXPERIMENTAL === 'true') {
-//   // `$ strapi transfer`
-//   program
-//     .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(
-//         '--to <destinationURL>',
-//         `URL of the remote Strapi instance to send data to`
-//       ).argParser(parseURL)
-//     )
-//     .addOption(forceOption)
-//     // Validate URLs
-//     .hook(
-//       'preAction',
-//       ifOptions(
-//         (opts) => opts.from,
-//         (thisCommand) => assertUrlHasProtocol(thisCommand.opts().from, ['https:', 'http:'])
-//       )
-//     )
-//     .hook(
-//       'preAction',
-//       ifOptions(
-//         (opts) => opts.to,
-//         (thisCommand) => assertUrlHasProtocol(thisCommand.opts().to, ['https:', 'http:'])
-//       )
-//     )
-//     .hook(
-//       'preAction',
-//       ifOptions(
-//         (opts) => !opts.from && !opts.to,
-//         () => exitWith(1, 'At least one source (from) or destination (to) option must be provided')
-//       )
-//     )
-//     .addOption(forceOption)
-//     .addOption(excludeOption)
-//     .addOption(onlyOption)
-//     .hook('preAction', validateExcludeOnly)
-//     .hook(
-//       'preAction',
-//       confirmMessage(
-//         'The import will delete all data in the remote database. Are you sure you want to proceed?'
-//       )
-//     )
-//     .action(getLocalScript('transfer/transfer'));
-// }
+// `$ strapi transfer`
+program
+  .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;
+        }
+      }
+    )
+  )
+  // 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 data in the remote database and media files. Are you sure you want to proceed?',
+          { failMessage: 'Transfer process aborted' }
+        )(thisCommand);
+      }
+    )
+  )
+  .action(getLocalScript('transfer/transfer'));
 
 // `$ strapi export`
 program
@@ -344,6 +373,7 @@ program
   .addOption(new Option('-f, --file <file>', 'name to use for exported file (without extensions)'))
   .addOption(excludeOption)
   .addOption(onlyOption)
+  .addOption(throttleOption)
   .hook('preAction', validateExcludeOnly)
   .hook('preAction', promptEncryptionKey)
   .action(getLocalScript('transfer/export'));
@@ -366,6 +396,7 @@ program
   .addOption(forceOption)
   .addOption(excludeOption)
   .addOption(onlyOption)
+  .addOption(throttleOption)
   .hook('preAction', validateExcludeOnly)
   .hook('preAction', async (thisCommand) => {
     const opts = thisCommand.opts();
@@ -382,7 +413,7 @@ program
           },
         ]);
         if (!answers.key?.length) {
-          exitWith(0, 'No key entered, aborting import.');
+          exitWith(1, 'No key entered, aborting import.');
         }
         opts.key = answers.key;
       }
@@ -420,7 +451,8 @@ program
   .hook(
     'preAction',
     confirmMessage(
-      'The import will delete all data in your database. Are you sure you want to proceed?'
+      'The import will delete all data in your database and media files. Are you sure you want to proceed?',
+      { failMessage: 'Import process aborted' }
     )
   )
   .action(getLocalScript('transfer/import'));

package/ee/index.js

@@ -3,7 +3,6 @@
 const { pick } = require('lodash/fp');
 
 const { readLicense, verifyLicense, fetchLicense, LicenseCheckError } = require('./license');
-const { eeStoreModel } = require('./ee-store');
 const { shiftCronExpression } = require('../lib/utils/cron');
 
 const ONE_MINUTE = 1000 * 60;
@@ -60,7 +59,7 @@ const onlineUpdate = async ({ strapi }) => {
 
   try {
     const storedInfo = await strapi.db
-      .queryBuilder(eeStoreModel.uid)
+      .queryBuilder('strapi::core-store')
       .where({ key: 'ee_information' })
       .select('value')
       .first()
@@ -101,7 +100,7 @@ const onlineUpdate = async ({ strapi }) => {
 
     if (shouldContactRegistry) {
       result.license = license ?? null;
-      const query = strapi.db.queryBuilder(eeStoreModel.uid).transacting(transaction);
+      const query = strapi.db.queryBuilder('strapi::core-store').transacting(transaction);
 
       if (!storedInfo) {
         query.insert({ key: 'ee_information', value: JSON.stringify(result) });
@@ -165,6 +164,10 @@ module.exports = Object.freeze({
     return ee.enabled;
   },
 
+  get seats() {
+    return ee.licenseInfo.seats;
+  },
+
   features: Object.freeze({
     list,
     get,

package/ee/license.js

@@ -10,7 +10,7 @@ const machineId = require('../lib/utils/machine-id');
 const DEFAULT_FEATURES = {
   bronze: [],
   silver: [],
-  gold: ['sso', { name: 'audit-logs', options: { retentionDays: 90 } }, 'review-workflows'],
+  gold: ['sso', { name: 'audit-logs', options: { retentionDays: 90 } }],
 };
 
 const publicKey = fs.readFileSync(join(__dirname, 'resources/key.pub'));

package/lib/Strapi.js

@@ -17,7 +17,6 @@ const { createServer } = require('./services/server');
 const createWebhookRunner = require('./services/webhook-runner');
 const { webhookModel, createWebhookStore } = require('./services/webhook-store');
 const { createCoreStore, coreStoreModel } = require('./services/core-store');
-const { eeStoreModel } = require('../ee/ee-store');
 const createEntityService = require('./services/entity-service');
 const createCronService = require('./services/cron');
 const entityValidator = require('./services/entity-validator');
@@ -117,7 +116,6 @@ class Strapi {
     this.cron = createCronService();
     this.telemetry = createTelemetry(this);
     this.requestContext = requestContext;
-
     this.customFields = createCustomFields(this);
 
     createUpdateNotifier(this).notify();
@@ -227,7 +225,6 @@ class Strapi {
 
   async destroy() {
     await this.server.destroy();
-
     await this.runLifecyclesFunctions(LIFECYCLES.DESTROY);
 
     this.eventHub.destroy();
@@ -409,7 +406,6 @@ class Strapi {
     const contentTypes = [
       coreStoreModel,
       webhookModel,
-      eeStoreModel,
       ...Object.values(strapi.contentTypes),
       ...Object.values(strapi.components),
     ];

package/lib/commands/transfer/export.js

@@ -1,36 +1,43 @@
 'use strict';
 
 const {
-  providers: { createLocalFileDestinationProvider },
-} = require('@strapi/data-transfer/lib/file');
-const {
-  providers: { createLocalStrapiSourceProvider },
-} = require('@strapi/data-transfer/lib/strapi');
-const { createTransferEngine } = require('@strapi/data-transfer/lib/engine');
+  file: {
+    providers: { createLocalFileDestinationProvider },
+  },
+  strapi: {
+    providers: { createLocalStrapiSourceProvider },
+  },
+  engine: { createTransferEngine },
+} = require('@strapi/data-transfer');
+
 const { isObject, isString, isFinite, toNumber } = require('lodash/fp');
 const fs = require('fs-extra');
 const chalk = require('chalk');
 
-const { TransferEngineTransferError } = require('@strapi/data-transfer/lib/engine/errors');
+const { TransferEngineTransferError } = require('@strapi/data-transfer').engine.errors;
 const {
   getDefaultExportName,
   buildTransferTable,
   DEFAULT_IGNORED_CONTENT_TYPES,
   createStrapiInstance,
   formatDiagnostic,
+  loadersFactory,
+  exitMessageText,
+  abortTransfer,
 } = require('./utils');
-
+const { exitWith } = require('../utils/helpers');
 /**
  * @typedef ExportCommandOptions Options given to the CLI import command
  *
- * @property {string} [file] The file path to import
+ * @property {string} [file] The file path to export to
  * @property {boolean} [encrypt] Used to encrypt the final archive
- * @property {string} [key] Encryption key, only useful when encryption is enabled
+ * @property {string} [key] Encryption key, used only when encryption is enabled
  * @property {boolean} [compress] Used to compress the final archive
+ * @property {(keyof import('@strapi/data-transfer/src/engine').TransferGroupFilter)[]} [only] If present, only include these filtered groups of data
+ * @property {(keyof import('@strapi/data-transfer/src/engine').TransferGroupFilter)[]} [exclude] If present, exclude these filtered groups of data
+ * @property {number|undefined} [throttle] Delay in ms after each record
  */
 
-const logger = console;
-
 const BYTES_IN_MB = 1024 * 1024;
 
 /**
@@ -43,8 +50,7 @@ const BYTES_IN_MB = 1024 * 1024;
 module.exports = async (opts) => {
   // Validate inputs from Commander
   if (!isObject(opts)) {
-    logger.error('Could not parse command arguments');
-    process.exit(1);
+    exitWith(1, 'Could not parse command arguments');
   }
 
   const strapi = await createStrapiInstance();
@@ -57,6 +63,7 @@ module.exports = async (opts) => {
     schemaStrategy: 'ignore', // for an export to file, schemaStrategy will always be skipped
     exclude: opts.exclude,
     only: opts.only,
+    throttle: opts.throttle,
     transforms: {
       links: [
         {
@@ -82,6 +89,20 @@ module.exports = async (opts) => {
 
   const progress = engine.progress.stream;
 
+  const { updateLoader } = loadersFactory();
+
+  progress.on(`stage::start`, ({ stage, data }) => {
+    updateLoader(stage, data).start();
+  });
+
+  progress.on('stage::finish', ({ stage, data }) => {
+    updateLoader(stage, data).succeed();
+  });
+
+  progress.on('stage::progress', ({ stage, data }) => {
+    updateLoader(stage, data);
+  });
+
   const getTelemetryPayload = (/* payload */) => {
     return {
       eventProperties: {
@@ -92,33 +113,41 @@ module.exports = async (opts) => {
   };
 
   progress.on('transfer::start', async () => {
-    logger.log(`Starting export...`);
+    console.log(`Starting export...`);
+
     await strapi.telemetry.send('didDEITSProcessStart', getTelemetryPayload());
   });
 
+  let results;
+  let outFile;
   try {
-    const results = await engine.transfer();
-    const outFile = results.destination.file.path;
-
-    const table = buildTransferTable(results.engine);
-    logger.log(table.toString());
-
+    // Abort transfer if user interrupts process
+    ['SIGTERM', 'SIGINT', 'SIGQUIT'].forEach((signal) => {
+      process.removeAllListeners(signal);
+      process.on(signal, () => abortTransfer({ engine, strapi }));
+    });
+
+    results = await engine.transfer();
+    outFile = results.destination.file.path;
     const outFileExists = await fs.pathExists(outFile);
     if (!outFileExists) {
       throw new TransferEngineTransferError(`Export file not created "${outFile}"`);
     }
-
-    logger.log(`${chalk.bold('Export process has been completed successfully!')}`);
-    logger.log(`Export archive is in ${chalk.green(outFile)}`);
   } catch {
     await strapi.telemetry.send('didDEITSProcessFail', getTelemetryPayload());
-    logger.error('Export process failed.');
-    process.exit(1);
+    exitWith(1, exitMessageText('export', true));
   }
 
-  // Note: Telemetry can't be sent in a finish event, because it runs async after this block but we can't await it, so if process.exit is used it won't send
   await strapi.telemetry.send('didDEITSProcessFinish', getTelemetryPayload());
-  process.exit(0);
+  try {
+    const table = buildTransferTable(results.engine);
+    console.log(table.toString());
+  } catch (e) {
+    console.error('There was an error displaying the results of the transfer.');
+  }
+
+  console.log(`Export archive is in ${chalk.green(outFile)}`);
+  exitWith(0, exitMessageText('export'));
 };
 
 /**

package/lib/commands/transfer/import.js

@@ -1,16 +1,14 @@
 'use strict';
 
 const {
-  providers: { createLocalFileSourceProvider },
-} = require('@strapi/data-transfer/lib/file');
-const {
-  providers: { createLocalStrapiDestinationProvider, DEFAULT_CONFLICT_STRATEGY },
-} = require('@strapi/data-transfer/lib/strapi');
-const {
-  createTransferEngine,
-  DEFAULT_VERSION_STRATEGY,
-  DEFAULT_SCHEMA_STRATEGY,
-} = require('@strapi/data-transfer/lib/engine');
+  file: {
+    providers: { createLocalFileSourceProvider },
+  },
+  strapi: {
+    providers: { createLocalStrapiDestinationProvider, DEFAULT_CONFLICT_STRATEGY },
+  },
+  engine: { createTransferEngine, DEFAULT_VERSION_STRATEGY, DEFAULT_SCHEMA_STRATEGY },
+} = require('@strapi/data-transfer');
 
 const { isObject } = require('lodash/fp');
 
@@ -19,19 +17,37 @@ const {
   DEFAULT_IGNORED_CONTENT_TYPES,
   createStrapiInstance,
   formatDiagnostic,
+  loadersFactory,
+  exitMessageText,
+  abortTransfer,
 } = require('./utils');
+const { exitWith } = require('../utils/helpers');
 
 /**
- * @typedef {import('@strapi/data-transfer').ILocalFileSourceProviderOptions} ILocalFileSourceProviderOptions
+ * @typedef {import('@strapi/data-transfer/src/file/providers').ILocalFileSourceProviderOptions} ILocalFileSourceProviderOptions
  */
 
-const logger = console;
+/**
+ * @typedef ImportCommandOptions Options given to the CLI import command
+ *
+ * @property {string} [file] The file path to import
+ * @property {string} [key] Encryption key, used when encryption is enabled
+ * @property {(keyof import('@strapi/data-transfer/src/engine').TransferGroupFilter)[]} [only] If present, only include these filtered groups of data
+ * @property {(keyof import('@strapi/data-transfer/src/engine').TransferGroupFilter)[]} [exclude] If present, exclude these filtered groups of data
+ * @property {number|undefined} [throttle] Delay in ms after each record
+ */
 
+/**
+ * Import command.
+ *
+ * It transfers data from a file to a local Strapi instance
+ *
+ * @param {ImportCommandOptions} opts
+ */
 module.exports = async (opts) => {
   // validate inputs from Commander
   if (!isObject(opts)) {
-    logger.error('Could not parse arguments');
-    process.exit(1);
+    exitWith(1, 'Could not parse arguments');
   }
 
   /**
@@ -66,6 +82,7 @@ module.exports = async (opts) => {
     schemaStrategy: opts.schemaStrategy || DEFAULT_SCHEMA_STRATEGY,
     exclude: opts.exclude,
     only: opts.only,
+    throttle: opts.throttle,
     rules: {
       links: [
         {
@@ -90,6 +107,21 @@ module.exports = async (opts) => {
   engine.diagnostics.onDiagnostic(formatDiagnostic('import'));
 
   const progress = engine.progress.stream;
+
+  const { updateLoader } = loadersFactory();
+
+  progress.on(`stage::start`, ({ stage, data }) => {
+    updateLoader(stage, data).start();
+  });
+
+  progress.on('stage::finish', ({ stage, data }) => {
+    updateLoader(stage, data).succeed();
+  });
+
+  progress.on('stage::progress', ({ stage, data }) => {
+    updateLoader(stage, data);
+  });
+
   const getTelemetryPayload = () => {
     return {
       eventProperties: {
@@ -100,27 +132,35 @@ module.exports = async (opts) => {
   };
 
   progress.on('transfer::start', async () => {
-    logger.info('Starting import...');
+    console.log('Starting import...');
     await strapiInstance.telemetry.send('didDEITSProcessStart', getTelemetryPayload());
   });
 
+  let results;
   try {
-    const results = await engine.transfer();
-    const table = buildTransferTable(results.engine);
-    logger.info(table.toString());
+    // Abort transfer if user interrupts process
+    ['SIGTERM', 'SIGINT', 'SIGQUIT'].forEach((signal) => {
+      process.removeAllListeners(signal);
+      process.on(signal, () => abortTransfer({ engine, strapi }));
+    });
 
-    logger.info('Import process has been completed successfully!');
+    results = await engine.transfer();
   } catch (e) {
     await strapiInstance.telemetry.send('didDEITSProcessFail', getTelemetryPayload());
-    logger.error('Import process failed.');
-    process.exit(1);
+    exitWith(1, exitMessageText('import', true));
+  }
+
+  try {
+    const table = buildTransferTable(results.engine);
+    console.log(table.toString());
+  } catch (e) {
+    console.error('There was an error displaying the results of the transfer.');
   }
 
-  // Note: Telemetry can't be sent in a finish event, because it runs async after this block but we can't await it, so if process.exit is used it won't send
   await strapiInstance.telemetry.send('didDEITSProcessFinish', getTelemetryPayload());
   await strapiInstance.destroy();
 
-  process.exit(0);
+  exitWith(0, exitMessageText('import'));
 };
 
 /**