@strapi/strapi 4.6.0-beta.0 → 4.6.0-beta.2

package/README.md

@@ -80,14 +80,18 @@ Complete installation requirements can be found in the documentation under <a hr
 - CentOS/RHEL 8
 - macOS Mojave
 - Windows 10
-- Docker - [Docker-Repo](https://github.com/strapi/strapi-docker)
+- Docker
 
 (Please note that Strapi may work on other operating systems, but these are not tested nor officially supported at this time.)
 
 **Node:**
 
-- NodeJS >= 14 <= 18
-- NPM >= 6.x
+Strapi only supports maintenance and LTS versions of Node.js. Please refer to the <a href="https://nodejs.org/en/about/releases/">Node.js release schedule</a> for more information. NPM versions installed by default with Node.js are supported. Generally it's recommended to use yarn over npm where possible.
+
+| Strapi Version | Recommended | Minimum |
+| -------------- | ----------- | ------- |
+| 4.3.9 and up   | 18.x        | 14.x    |
+| 4.0.x to 4.3.8 | 16.x        | 14.x    |
 
 **Database:**
 
@@ -98,7 +102,7 @@ Complete installation requirements can be found in the documentation under <a hr
 | PostgreSQL | 11.0    | 14.0        |
 | SQLite     | 3       | 3           |
 
-**We recommend always using the latest version of Strapi to start your new projects**.
+**We recommend always using the latest version of Strapi stable to start your new projects**.
 
 ## Features
 

package/bin/strapi.js

@@ -5,13 +5,27 @@
 // FIXME
 /* eslint-disable import/extensions */
 const _ = require('lodash');
+const path = require('path');
 const resolveCwd = require('resolve-cwd');
 const { yellow } = require('chalk');
-const { Command } = require('commander');
+const { Command, Option } = require('commander');
+const inquirer = require('inquirer');
 
 const program = new Command();
 
 const packageJSON = require('../package.json');
+const {
+  promptEncryptionKey,
+  confirmMessage,
+  parseURL,
+  forceOption,
+} = require('../lib/commands/utils/commander');
+const { ifOptions, assertUrlHasProtocol, exitWith } = require('../lib/commands/utils/helpers');
+const {
+  excludeOption,
+  onlyOption,
+  validateExcludeOnly,
+} = require('../lib/commands/transfer/utils');
 
 const checkCwdIsStrapiApp = (name) => {
   const logErrorAndExit = () => {
@@ -255,4 +269,128 @@ 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 export`
+program
+  .command('export')
+  .description('Export data from Strapi to file')
+  .allowExcessArguments(false)
+  .addOption(
+    new Option('--no-encrypt', `Disables 'aes-128-ecb' encryption of the output file`).default(true)
+  )
+  .addOption(new Option('--no-compress', 'Disables gzip compression of output file').default(true))
+  .addOption(
+    new Option(
+      '-k, --key <string>',
+      'Provide encryption key in command instead of using the prompt'
+    )
+  )
+  .addOption(new Option('-f, --file <file>', 'name to use for exported file (without extensions)'))
+  .addOption(excludeOption)
+  .addOption(onlyOption)
+  .hook('preAction', validateExcludeOnly)
+  .hook('preAction', promptEncryptionKey)
+  .action(getLocalScript('transfer/export'));
+
+// `$ strapi import`
+program
+  .command('import')
+  .description('Import data from file to Strapi')
+  .allowExcessArguments(false)
+  .requiredOption(
+    '-f, --file <file>',
+    'path and filename for the Strapi export file you want to import'
+  )
+  .addOption(
+    new Option(
+      '-k, --key <string>',
+      'Provide encryption key in command instead of using the prompt'
+    )
+  )
+  .addOption(forceOption)
+  .addOption(excludeOption)
+  .addOption(onlyOption)
+  .hook('preAction', validateExcludeOnly)
+  .hook('preAction', async (thisCommand) => {
+    const opts = thisCommand.opts();
+    const ext = path.extname(String(opts.file));
+
+    // check extension to guess if we should prompt for key
+    if (ext === '.enc') {
+      if (!opts.key) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'password',
+            message: 'Please enter your decryption key',
+            name: 'key',
+          },
+        ]);
+        if (!answers.key?.length) {
+          exitWith(0, 'No key entered, aborting import.');
+        }
+        opts.key = answers.key;
+      }
+    }
+  })
+  .hook(
+    'preAction',
+    confirmMessage(
+      'The import will delete all data in your database. Are you sure you want to proceed?'
+    )
+  )
+  .action(getLocalScript('transfer/import'));
+
 program.parseAsync(process.argv);

package/lib/Strapi.js

@@ -225,7 +225,7 @@ class Strapi {
 
     await this.runLifecyclesFunctions(LIFECYCLES.DESTROY);
 
-    this.eventHub.removeAllListeners();
+    this.eventHub.destroy();
 
     if (_.has(this, 'db')) {
       await this.db.destroy();
@@ -242,11 +242,14 @@ class Strapi {
   sendStartupTelemetry() {
     // Emit started event.
     // do not await to avoid slower startup
+    // This event is anonymous
     this.telemetry.send('didStartServer', {
-      database: strapi.config.get('database.connection.client'),
-      plugins: Object.keys(strapi.plugins),
-      // TODO: to add back
-      // providers: this.config.installedProviders,
+      groupProperties: {
+        database: strapi.config.get('database.connection.client'),
+        plugins: Object.keys(strapi.plugins),
+        // TODO: to add back
+        // providers: this.config.installedProviders,
+      },
     });
   }
 

package/lib/commands/opt-in-telemetry.js

@@ -53,12 +53,12 @@ const generateNewPackageJSON = (packageObj) => {
 
 const sendEvent = async (uuid) => {
   try {
-    await fetch('https://analytics.strapi.io/track', {
+    await fetch('https://analytics.strapi.io/api/v2/track', {
       method: 'POST',
       body: JSON.stringify({
         event: 'didOptInTelemetry',
-        uuid,
         deviceId: machineID(),
+        groupProperties: { projectId: uuid },
       }),
       headers: { 'Content-Type': 'application/json' },
     });

package/lib/commands/opt-out-telemetry.js

@@ -28,12 +28,12 @@ const writePackageJSON = async (path, file, spacing) => {
 
 const sendEvent = async (uuid) => {
   try {
-    await fetch('https://analytics.strapi.io/track', {
+    await fetch('https://analytics.strapi.io/api/v2/track', {
       method: 'POST',
       body: JSON.stringify({
         event: 'didOptOutTelemetry',
-        uuid,
         deviceId: machineID(),
+        groupProperties: { projectId: uuid },
       }),
       headers: { 'Content-Type': 'application/json' },
     });

package/lib/commands/transfer/export.js

@@ -0,0 +1,158 @@
+'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');
+const { isObject, isString, isFinite, toNumber } = require('lodash/fp');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+
+const {
+  getDefaultExportName,
+  buildTransferTable,
+  DEFAULT_IGNORED_CONTENT_TYPES,
+  createStrapiInstance,
+} = require('./utils');
+
+/**
+ * @typedef ImportCommandOptions Options given to the CLI import command
+ *
+ * @property {string} [file] The file path to import
+ * @property {boolean} [encrypt] Used to encrypt the final archive
+ * @property {string} [key] Encryption key, only useful when encryption is enabled
+ * @property {boolean} [compress] Used to compress the final archive
+ */
+
+const logger = console;
+
+const BYTES_IN_MB = 1024 * 1024;
+
+/**
+ * Import command.
+ *
+ * It transfers data from a local 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 command arguments');
+    process.exit(1);
+  }
+
+  const strapi = await createStrapiInstance();
+
+  const source = createSourceProvider(strapi);
+  const destination = createDestinationProvider(opts);
+
+  const engine = createTransferEngine(source, destination, {
+    versionStrategy: 'ignore', // for an export to file, versionStrategy will always be skipped
+    schemaStrategy: 'ignore', // for an export to file, schemaStrategy will always be skipped
+    exclude: opts.exclude,
+    only: opts.only,
+    transforms: {
+      links: [
+        {
+          filter(link) {
+            return (
+              !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.left.type) &&
+              !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.right.type)
+            );
+          },
+        },
+      ],
+      entities: [
+        {
+          filter(entity) {
+            return !DEFAULT_IGNORED_CONTENT_TYPES.includes(entity.type);
+          },
+        },
+      ],
+    },
+  });
+
+  const progress = engine.progress.stream;
+
+  const getTelemetryPayload = (/* payload */) => {
+    return {
+      eventProperties: {
+        source: engine.sourceProvider.name,
+        destination: engine.destinationProvider.name,
+      },
+    };
+  };
+
+  progress.on('transfer::start', async () => {
+    logger.log(`Starting export...`);
+    await strapi.telemetry.send('didDEITSProcessStart', getTelemetryPayload());
+  });
+
+  try {
+    const results = await engine.transfer();
+    const outFile = results.destination.file.path;
+
+    const table = buildTransferTable(results.engine);
+    logger.log(table.toString());
+
+    const outFileExists = await fs.pathExists(outFile);
+    if (!outFileExists) {
+      throw new Error(`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 (e) {
+    await strapi.telemetry.send('didDEITSProcessFail', getTelemetryPayload());
+    logger.error('Export process failed unexpectedly:', e.toString());
+    process.exit(1);
+  }
+
+  // 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);
+};
+
+/**
+ * It creates a local strapi destination provider
+ */
+const createSourceProvider = (strapi) => {
+  return createLocalStrapiSourceProvider({
+    async getStrapi() {
+      return strapi;
+    },
+  });
+};
+
+/**
+ * It creates a local file destination provider based on the given options
+ *
+ * @param {ImportCommandOptions} opts
+ */
+const createDestinationProvider = (opts) => {
+  const { file, compress, encrypt, key, maxSizeJsonl } = opts;
+
+  const filepath = isString(file) && file.length > 0 ? file : getDefaultExportName();
+
+  const maxSizeJsonlInMb = isFinite(toNumber(maxSizeJsonl))
+    ? toNumber(maxSizeJsonl) * BYTES_IN_MB
+    : undefined;
+
+  return createLocalFileDestinationProvider({
+    file: {
+      path: filepath,
+      maxSizeJsonl: maxSizeJsonlInMb,
+    },
+    encryption: {
+      enabled: encrypt,
+      key: encrypt ? key : undefined,
+    },
+    compression: {
+      enabled: compress,
+    },
+  });
+};

package/lib/commands/transfer/import.js

@@ -0,0 +1,154 @@
+'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');
+
+const { isObject } = require('lodash/fp');
+const path = require('path');
+
+const strapi = require('../../index');
+const { buildTransferTable, DEFAULT_IGNORED_CONTENT_TYPES } = require('./utils');
+
+/**
+ * @typedef {import('@strapi/data-transfer').ILocalFileSourceProviderOptions} ILocalFileSourceProviderOptions
+ */
+
+const logger = console;
+
+module.exports = async (opts) => {
+  // validate inputs from Commander
+  if (!isObject(opts)) {
+    logger.error('Could not parse arguments');
+    process.exit(1);
+  }
+
+  /**
+   * From strapi backup file
+   */
+  const sourceOptions = getLocalFileSourceOptions(opts);
+
+  const source = createLocalFileSourceProvider(sourceOptions);
+
+  /**
+   * To local Strapi instance
+   */
+  const strapiInstance = await strapi(await strapi.compile()).load();
+
+  const destinationOptions = {
+    async getStrapi() {
+      return strapiInstance;
+    },
+    autoDestroy: false,
+    strategy: opts.conflictStrategy || DEFAULT_CONFLICT_STRATEGY,
+    restore: {
+      entities: { exclude: DEFAULT_IGNORED_CONTENT_TYPES },
+    },
+  };
+  const destination = createLocalStrapiDestinationProvider(destinationOptions);
+
+  /**
+   * Configure and run the transfer engine
+   */
+  const engineOptions = {
+    versionStrategy: opts.versionStrategy || DEFAULT_VERSION_STRATEGY,
+    schemaStrategy: opts.schemaStrategy || DEFAULT_SCHEMA_STRATEGY,
+    exclude: opts.exclude,
+    only: opts.only,
+    rules: {
+      links: [
+        {
+          filter(link) {
+            return (
+              !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.left.type) &&
+              !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.right.type)
+            );
+          },
+        },
+      ],
+      entities: [
+        {
+          filter: (entity) => !DEFAULT_IGNORED_CONTENT_TYPES.includes(entity.type),
+        },
+      ],
+    },
+  };
+
+  const engine = createTransferEngine(source, destination, engineOptions);
+
+  const progress = engine.progress.stream;
+  const getTelemetryPayload = () => {
+    return {
+      eventProperties: {
+        source: engine.sourceProvider.name,
+        destination: engine.destinationProvider.name,
+      },
+    };
+  };
+
+  progress.on('transfer::start', async () => {
+    logger.info('Starting import...');
+    await strapiInstance.telemetry.send('didDEITSProcessStart', getTelemetryPayload());
+  });
+
+  try {
+    const results = await engine.transfer();
+    const table = buildTransferTable(results.engine);
+    logger.info(table.toString());
+
+    logger.info('Import process has been completed successfully!');
+  } catch (e) {
+    await strapiInstance.telemetry.send('didDEITSProcessFail', getTelemetryPayload());
+    logger.error('Import process failed unexpectedly:');
+    logger.error(e);
+    process.exit(1);
+  }
+
+  // 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);
+};
+
+/**
+ * Infer local file source provider options based on a given filename
+ *
+ * @param {{ file: string; key?: string }} opts
+ *
+ * @return {ILocalFileSourceProviderOptions}
+ */
+const getLocalFileSourceOptions = (opts) => {
+  /**
+   * @type {ILocalFileSourceProviderOptions}
+   */
+  const options = {
+    file: { path: opts.file },
+    compression: { enabled: false },
+    encryption: { enabled: false },
+  };
+
+  const { extname, parse } = path;
+
+  let file = options.file.path;
+
+  if (extname(file) === '.enc') {
+    file = parse(file).name;
+    options.encryption = { enabled: true, key: opts.key };
+  }
+
+  if (extname(file) === '.gz') {
+    file = parse(file).name;
+    options.compression = { enabled: true };
+  }
+
+  return options;
+};

package/lib/commands/transfer/transfer.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const { createTransferEngine } = require('@strapi/data-transfer/lib/engine');
+const {
+  providers: {
+    createRemoteStrapiDestinationProvider,
+    createLocalStrapiSourceProvider,
+    createLocalStrapiDestinationProvider,
+  },
+} = require('@strapi/data-transfer/lib/strapi');
+const { isObject } = require('lodash/fp');
+const chalk = require('chalk');
+
+const {
+  buildTransferTable,
+  createStrapiInstance,
+  DEFAULT_IGNORED_CONTENT_TYPES,
+} = require('./utils');
+
+const logger = console;
+
+/**
+ * @typedef TransferCommandOptions Options given to the CLI transfer command
+ *
+ * @property {URL|undefined} [to] The url of a remote Strapi to use as remote destination
+ * @property {URL|undefined} [from] The url of a remote Strapi to use as remote source
+ */
+
+/**
+ * Transfer command.
+ *
+ * It transfers data from a local file to a local strapi instance
+ *
+ * @param {TransferCommandOptions} opts
+ */
+module.exports = async (opts) => {
+  // Validate inputs from Commander
+  if (!isObject(opts)) {
+    logger.error('Could not parse command arguments');
+    process.exit(1);
+  }
+
+  const strapi = await createStrapiInstance();
+
+  let source;
+  let destination;
+
+  if (!opts.from && !opts.to) {
+    logger.error('At least one source (from) or destination (to) option must be provided');
+    process.exit(1);
+  }
+
+  // if no URL provided, use local Strapi
+  if (!opts.from) {
+    source = createLocalStrapiSourceProvider({
+      getStrapi: () => strapi,
+    });
+  }
+  // if URL provided, set up a remote source provider
+  else {
+    logger.error(`Remote Strapi source provider not yet implemented`);
+    process.exit(1);
+  }
+
+  // if no URL provided, use local Strapi
+  if (!opts.to) {
+    destination = createLocalStrapiDestinationProvider({
+      getStrapi: () => strapi,
+    });
+  }
+  // if URL provided, set up a remote destination provider
+  else {
+    destination = createRemoteStrapiDestinationProvider({
+      url: opts.to,
+      auth: false,
+      strategy: 'restore',
+      restore: {
+        entities: { exclude: DEFAULT_IGNORED_CONTENT_TYPES },
+      },
+    });
+  }
+
+  if (!source || !destination) {
+    logger.error('Could not create providers');
+    process.exit(1);
+  }
+
+  const engine = createTransferEngine(source, destination, {
+    versionStrategy: 'strict',
+    schemaStrategy: 'strict',
+    transforms: {
+      links: [
+        {
+          filter(link) {
+            return (
+              !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.left.type) &&
+              !DEFAULT_IGNORED_CONTENT_TYPES.includes(link.right.type)
+            );
+          },
+        },
+      ],
+      entities: [
+        {
+          filter(entity) {
+            return !DEFAULT_IGNORED_CONTENT_TYPES.includes(entity.type);
+          },
+        },
+      ],
+    },
+  });
+
+  try {
+    logger.log(`Starting transfer...`);
+
+    const results = await engine.transfer();
+
+    const table = buildTransferTable(results.engine);
+    logger.log(table.toString());
+
+    logger.log(`${chalk.bold('Transfer process has been completed successfully!')}`);
+    process.exit(0);
+  } catch (e) {
+    logger.error('Transfer process failed unexpectedly');
+    logger.error(e);
+    process.exit(1);
+  }
+};