@strapi/strapi 4.6.0-beta.1 → 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

@@ -14,7 +14,18 @@ const inquirer = require('inquirer');
 const program = new Command();
 
 const packageJSON = require('../package.json');
-const { promptEncryptionKey, confirmMessage } = require('../lib/commands/utils/commander');
+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 = () => {
@@ -258,10 +269,65 @@ 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)
   )
@@ -273,7 +339,9 @@ program
     )
   )
   .addOption(new Option('-f, --file <file>', 'name to use for exported file (without extensions)'))
-  .allowExcessArguments(false)
+  .addOption(excludeOption)
+  .addOption(onlyOption)
+  .hook('preAction', validateExcludeOnly)
   .hook('preAction', promptEncryptionKey)
   .action(getLocalScript('transfer/export'));
 
@@ -281,6 +349,7 @@ program
 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'
@@ -291,7 +360,10 @@ program
       'Provide encryption key in command instead of using the prompt'
     )
   )
-  .allowExcessArguments(false)
+  .addOption(forceOption)
+  .addOption(excludeOption)
+  .addOption(onlyOption)
+  .hook('preAction', validateExcludeOnly)
   .hook('preAction', async (thisCommand) => {
     const opts = thisCommand.opts();
     const ext = path.extname(String(opts.file));
@@ -307,8 +379,7 @@ program
           },
         ]);
         if (!answers.key?.length) {
-          console.log('No key entered, aborting import.');
-          process.exit(0);
+          exitWith(0, 'No key entered, aborting import.');
         }
         opts.key = answers.key;
       }

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();

package/lib/commands/transfer/export.js

@@ -1,12 +1,12 @@
 'use strict';
 
 const {
-  createLocalFileDestinationProvider,
-  createLocalStrapiSourceProvider,
-  createTransferEngine,
-  // TODO: we need to solve this issue with typescript modules
-  // eslint-disable-next-line import/no-unresolved, node/no-missing-require
-} = require('@strapi/data-transfer');
+  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');
@@ -53,6 +53,8 @@ module.exports = async (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: [
         {
@@ -74,32 +76,23 @@ module.exports = async (opts) => {
     },
   });
 
-  try {
-    logger.log(`Starting export...`);
-
-    const progress = engine.progress.stream;
+  const progress = engine.progress.stream;
 
-    const telemetryPayload = (/* payload */) => {
-      return {
-        eventProperties: {
-          source: engine.sourceProvider.name,
-          destination: engine.destinationProvider.name,
-        },
-      };
+  const getTelemetryPayload = (/* payload */) => {
+    return {
+      eventProperties: {
+        source: engine.sourceProvider.name,
+        destination: engine.destinationProvider.name,
+      },
     };
+  };
 
-    progress.on('transfer::start', (payload) => {
-      strapi.telemetry.send('didDEITSProcessStart', telemetryPayload(payload));
-    });
-
-    progress.on('transfer::finish', (payload) => {
-      strapi.telemetry.send('didDEITSProcessFinish', telemetryPayload(payload));
-    });
-
-    progress.on('transfer::error', (payload) => {
-      strapi.telemetry.send('didDEITSProcessFail', telemetryPayload(payload));
-    });
+  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;
 
@@ -113,11 +106,15 @@ module.exports = async (opts) => {
 
     logger.log(`${chalk.bold('Export process has been completed successfully!')}`);
     logger.log(`Export archive is in ${chalk.green(outFile)}`);
-    process.exit(0);
   } 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);
 };
 
 /**

package/lib/commands/transfer/import.js

@@ -1,15 +1,17 @@
 'use strict';
 
 const {
-  createLocalFileSourceProvider,
-  createLocalStrapiDestinationProvider,
+  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,
-  DEFAULT_CONFLICT_STRATEGY,
-  // TODO: we need to solve this issue with typescript modules
-  // eslint-disable-next-line import/no-unresolved, node/no-missing-require
-} = require('@strapi/data-transfer');
+} = require('@strapi/data-transfer/lib/engine');
+
 const { isObject } = require('lodash/fp');
 const path = require('path');
 
@@ -45,6 +47,7 @@ module.exports = async (opts) => {
     async getStrapi() {
       return strapiInstance;
     },
+    autoDestroy: false,
     strategy: opts.conflictStrategy || DEFAULT_CONFLICT_STRATEGY,
     restore: {
       entities: { exclude: DEFAULT_IGNORED_CONTENT_TYPES },
@@ -59,6 +62,7 @@ module.exports = async (opts) => {
     versionStrategy: opts.versionStrategy || DEFAULT_VERSION_STRATEGY,
     schemaStrategy: opts.schemaStrategy || DEFAULT_SCHEMA_STRATEGY,
     exclude: opts.exclude,
+    only: opts.only,
     rules: {
       links: [
         {
@@ -77,44 +81,42 @@ module.exports = async (opts) => {
       ],
     },
   };
-  const engine = createTransferEngine(source, destination, engineOptions);
 
-  try {
-    logger.info('Starting import...');
+  const engine = createTransferEngine(source, destination, engineOptions);
 
-    const progress = engine.progress.stream;
-    const telemetryPayload = (/* payload */) => {
-      return {
-        eventProperties: {
-          source: engine.sourceProvider.name,
-          destination: engine.destinationProvider.name,
-        },
-      };
+  const progress = engine.progress.stream;
+  const getTelemetryPayload = () => {
+    return {
+      eventProperties: {
+        source: engine.sourceProvider.name,
+        destination: engine.destinationProvider.name,
+      },
     };
+  };
 
-    progress.on('transfer::start', (payload) => {
-      strapiInstance.telemetry.send('didDEITSProcessStart', telemetryPayload(payload));
-    });
-
-    progress.on('transfer::finish', (payload) => {
-      strapiInstance.telemetry.send('didDEITSProcessFinish', telemetryPayload(payload));
-    });
-
-    progress.on('transfer::error', (payload) => {
-      strapiInstance.telemetry.send('didDEITSProcessFail', telemetryPayload(payload));
-    });
+  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!');
-    process.exit(0);
   } 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);
 };
 
 /**

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);
+  }
+};

package/lib/commands/transfer/utils.js

@@ -2,8 +2,11 @@
 
 const chalk = require('chalk');
 const Table = require('cli-table3');
-const { readableBytes } = require('../utils');
+const { Option } = require('commander');
+const { TransferGroupPresets } = require('@strapi/data-transfer/lib/engine');
+const { readableBytes, exitWith } = require('../utils/helpers');
 const strapi = require('../../index');
+const { getParseListWithChoices } = require('../utils/commander');
 
 const pad = (n) => {
   return (n < 10 ? '0' : '') + String(n);
@@ -85,10 +88,45 @@ const createStrapiInstance = async (logLevel = 'error') => {
   return app.load();
 };
 
+const transferDataTypes = Object.keys(TransferGroupPresets);
+
+const excludeOption = new Option(
+  '--exclude <comma-separated data types>',
+  `Exclude this data. Options used here override --only. Available types: ${transferDataTypes.join(
+    ','
+  )}`
+).argParser(getParseListWithChoices(transferDataTypes, 'Invalid options for "exclude"'));
+
+const onlyOption = new Option(
+  '--only <command-separated data types>',
+  `Include only this data (plus schemas). Available types: ${transferDataTypes.join(',')}`
+).argParser(getParseListWithChoices(transferDataTypes, 'Invalid options for "only"'));
+
+const validateExcludeOnly = (command) => {
+  const { exclude, only } = command.opts();
+  if (!only || !exclude) {
+    return;
+  }
+
+  const choicesInBoth = only.filter((n) => {
+    return exclude.indexOf(n) !== -1;
+  });
+  if (choicesInBoth.length > 0) {
+    exitWith(
+      1,
+      `Data types may not be used in both "exclude" and "only" in the same command. Found in both: ${choicesInBoth.join(
+        ','
+      )}`
+    );
+  }
+};
+
 module.exports = {
   buildTransferTable,
   getDefaultExportName,
-  yyyymmddHHMMSS,
   DEFAULT_IGNORED_CONTENT_TYPES,
   createStrapiInstance,
+  excludeOption,
+  onlyOption,
+  validateExcludeOnly,
 };

package/lib/commands/utils/commander.js

@@ -1,12 +1,59 @@
 'use strict';
 
+/**
+ * This file includes hooks to use for commander.hook and argParsers for commander.argParser
+ */
+
 const inquirer = require('inquirer');
+const { InvalidOptionArgumentError, Option } = require('commander');
+const { bold, green, cyan } = require('chalk');
+const { exitWith } = require('./helpers');
+
+/**
+ * argParser: Parse a comma-delimited string as an array
+ */
+const parseList = (value) => {
+  let list;
+  try {
+    list = value.split(',').map((item) => item.trim()); // trim shouldn't be necessary but might help catch unexpected whitespace characters
+  } catch (e) {
+    exitWith(1, `Unrecognized input: ${value}`);
+  }
+  return list;
+};
+
+/**
+ * Returns an argParser that returns a list
+ */
+const getParseListWithChoices = (choices, errorMessage = 'Invalid options:') => {
+  return (value) => {
+    const list = parseList(value);
+    const invalid = list.filter((item) => {
+      return !choices.includes(item);
+    });
+
+    if (invalid.length > 0) {
+      exitWith(1, `${errorMessage}: ${invalid.join(',')}`);
+    }
+
+    return list;
+  };
+};
 
 /**
- * argsParser: Parse a comma-delimited string as an array
+ * argParser: Parse a string as a URL object
  */
-const parseInputList = (value) => {
-  return value.split(',');
+const parseURL = (value) => {
+  try {
+    const url = new URL(value);
+    if (!url.host) {
+      throw new InvalidOptionArgumentError(`Could not parse url ${value}`);
+    }
+
+    return url;
+  } catch (e) {
+    throw new InvalidOptionArgumentError(`Could not parse url ${value}`);
+  }
 };
 
 /**
@@ -16,8 +63,7 @@ const promptEncryptionKey = async (thisCommand) => {
   const opts = thisCommand.opts();
 
   if (!opts.encrypt && opts.key) {
-    console.error('Key may not be present unless encryption is used');
-    process.exit(1);
+    return exitWith(1, 'Key may not be present unless encryption is used');
   }
 
   // if encrypt==true but we have no key, prompt for it
@@ -37,21 +83,30 @@ const promptEncryptionKey = async (thisCommand) => {
       ]);
       opts.key = answers.key;
     } catch (e) {
-      console.error('Failed to get encryption key');
-      process.exit(1);
+      return exitWith(1, 'Failed to get encryption key');
     }
     if (!opts.key) {
-      console.error('Failed to get encryption key');
-      process.exit(1);
+      return exitWith(1, 'Failed to get encryption key');
     }
   }
 };
 
 /**
- * hook: require a confirmation message to be accepted
+ * hook: require a confirmation message to be accepted unless forceOption (-f,--force) is used
+ *
+ * @param {string} message The message to confirm with user
+ * @param {object} options Additional options
  */
 const confirmMessage = (message) => {
-  return async () => {
+  return async (command) => {
+    // if we have a force option, assume yes
+    const opts = command.opts();
+    if (opts?.force === true) {
+      // attempt to mimic the inquirer prompt exactly
+      console.log(`${green('?')} ${bold(message)} ${cyan('Yes')}`);
+      return;
+    }
+
     const answers = await inquirer.prompt([
       {
         type: 'confirm',
@@ -61,13 +116,21 @@ const confirmMessage = (message) => {
       },
     ]);
     if (!answers.confirm) {
-      process.exit(0);
+      exitWith(0);
     }
   };
 };
 
+const forceOption = new Option(
+  '-f, --force',
+  `Automatically answer "yes" to all prompts, including potentially destructive requests, and run non-interactively.`
+);
+
 module.exports = {
-  parseInputList,
+  getParseListWithChoices,
+  parseList,
+  parseURL,
   promptEncryptionKey,
   confirmMessage,
+  forceOption,
 };

package/lib/commands/utils/helpers.js

@@ -0,0 +1,108 @@
+'use strict';
+
+/**
+ * Helper functions for the Strapi CLI
+ */
+
+const chalk = require('chalk');
+const { isString, isArray } = require('lodash/fp');
+
+const bytesPerKb = 1024;
+const sizes = ['B ', 'KB', 'MB', 'GB', 'TB', 'PB'];
+
+/**
+ * Convert bytes to a human readable formatted string, for example "1024" becomes "1KB"
+ *
+ * @param {number} bytes The bytes to be converted
+ * @param {number} decimals How many decimals to include in the final number
+ * @param {number} padStart Pad the string with space at the beginning so that it has at least this many characters
+ */
+const readableBytes = (bytes, decimals = 1, padStart = 0) => {
+  if (!bytes) {
+    return '0';
+  }
+  const i = Math.floor(Math.log(bytes) / Math.log(bytesPerKb));
+  const result = `${parseFloat((bytes / bytesPerKb ** i).toFixed(decimals))} ${sizes[i].padStart(
+    2
+  )}`;
+
+  return result.padStart(padStart);
+};
+
+/**
+ *
+ * Display message(s) to console and then call process.exit with code.
+ * If code is zero, console.log and green text is used for messages, otherwise console.error and red text.
+ *
+ * @param {number} code Code to exit process with
+ * @param {string | Array} message Message(s) to display before exiting
+ */
+const exitWith = (code, message = undefined) => {
+  const logger = (message) => {
+    if (code === 0) {
+      console.log(chalk.green(message));
+    } else {
+      console.error(chalk.red(message));
+    }
+  };
+
+  if (isString(message)) {
+    logger(message);
+  } else if (isArray(message)) {
+    message.forEach((msg) => logger(msg));
+  }
+  process.exit(code);
+};
+
+/**
+ * assert that a URL object has a protocol value
+ *
+ * @param {URL} url
+ * @param {string[]|string|undefined} [protocol]
+ */
+const assertUrlHasProtocol = (url, protocol = undefined) => {
+  if (!url.protocol) {
+    exitWith(1, `${url.toString()} does not have a protocol`);
+  }
+
+  // if just checking for the existence of a protocol, return
+  if (!protocol) {
+    return;
+  }
+
+  if (isString(protocol)) {
+    if (protocol !== url.protocol) {
+      exitWith(1, `${url.toString()} must have the protocol ${protocol}`);
+    }
+    return;
+  }
+
+  // assume an array
+  if (!protocol.some((protocol) => url.protocol === protocol)) {
+    return exitWith(
+      1,
+      `${url.toString()} must have one of the following protocols: ${protocol.join(',')}`
+    );
+  }
+};
+
+/**
+ * Passes commander options to conditionCallback(). If it returns true, call isMetCallback otherwise call isNotMetCallback
+ */
+const ifOptions = (conditionCallback, isMetCallback = () => {}, isNotMetCallback = () => {}) => {
+  return async (command) => {
+    const opts = command.opts();
+    if (await conditionCallback(opts)) {
+      await isMetCallback(command);
+    } else {
+      await isNotMetCallback(command);
+    }
+  };
+};
+
+module.exports = {
+  exitWith,
+  assertUrlHasProtocol,
+  ifOptions,
+  readableBytes,
+};

package/lib/core-api/service/index.d.ts

@@ -21,5 +21,5 @@ export interface CollectionTypeService extends BaseService {
 export type Service = SingleTypeService | CollectionTypeService;
 
 export type GenericService = Partial<Service> & {
-  [method: string | number | symbol]: <T = any>(...args: any) => T;
+  [method: string | number | symbol]: (...args: any) => any;
 };

package/lib/core-api/service/single-type.js

@@ -1,6 +1,16 @@
 'use strict';
 
+const { propOr } = require('lodash/fp');
+
 const { ValidationError } = require('@strapi/utils').errors;
+const {
+  hasDraftAndPublish,
+  constants: { PUBLISHED_AT_ATTRIBUTE },
+} = require('@strapi/utils').contentTypes;
+
+const setPublishedAt = (data) => {
+  data[PUBLISHED_AT_ATTRIBUTE] = propOr(new Date(), PUBLISHED_AT_ATTRIBUTE, data);
+};
 
 /**
  * Returns a single type service to handle default core-api actions
@@ -27,7 +37,7 @@ const createSingleTypeService = ({ contentType }) => {
      * @return {Promise}
      */
     async createOrUpdate({ data, ...params } = {}) {
-      const entity = await this.find(params);
+      const entity = await this.find({ ...params, publicationState: 'preview' });
 
       if (!entity) {
         const count = await strapi.query(uid).count();
@@ -35,6 +45,9 @@ const createSingleTypeService = ({ contentType }) => {
           throw new ValidationError('singleType.alreadyExists');
         }
 
+        if (hasDraftAndPublish(contentType)) {
+          setPublishedAt(data);
+        }
         return strapi.entityService.create(uid, { ...params, data });
       }
 

package/lib/services/entity-service/index.js

@@ -2,7 +2,7 @@
 
 const _ = require('lodash');
 const delegate = require('delegates');
-const { InvalidTimeError, InvalidDateError, InvalidDateTimeError } =
+const { InvalidTimeError, InvalidDateError, InvalidDateTimeError, InvalidRelationError } =
   require('@strapi/database').errors;
 const {
   webhook: webhookUtils,
@@ -34,7 +34,12 @@ const transformLoadParamsToQuery = (uid, field, params = {}, pagination = {}) =>
 // TODO: those should be strapi events used by the webhooks not the other way arround
 const { ENTRY_CREATE, ENTRY_UPDATE, ENTRY_DELETE } = webhookUtils.webhookEvents;
 
-const databaseErrorsToTransform = [InvalidTimeError, InvalidDateTimeError, InvalidDateError];
+const databaseErrorsToTransform = [
+  InvalidTimeError,
+  InvalidDateTimeError,
+  InvalidDateError,
+  InvalidRelationError,
+];
 
 const creationPipeline = (data, context) => {
   return applyTransforms(data, context);
@@ -55,6 +60,11 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
   },
 
   async emitEvent(uid, event, entity) {
+    // Ignore audit log events to prevent infinite loops
+    if (uid === 'admin::audit-log') {
+      return;
+    }
+
     const model = strapi.getModel(uid);
     const sanitizedEntity = await sanitize.sanitizers.defaultSanitizeOutput(model, entity);
 

package/lib/services/errors.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const createError = require('http-errors');
-const { NotFoundError, UnauthorizedError, ForbiddenError, PayloadTooLargeError } =
+const { NotFoundError, UnauthorizedError, ForbiddenError, PayloadTooLargeError, RateLimitError } =
   require('@strapi/utils').errors;
 
 const mapErrorsAndStatus = [
@@ -21,6 +21,10 @@ const mapErrorsAndStatus = [
     classError: PayloadTooLargeError,
     status: 413,
   },
+  {
+    classError: RateLimitError,
+    status: 429,
+  },
 ];
 
 const formatApplicationError = (error) => {

package/lib/services/event-hub.js

@@ -1,16 +1,78 @@
+'use strict';
+
 /**
  * The event hub is Strapi's event control center.
  */
+module.exports = function createEventHub() {
+  const listeners = new Map();
 
-'use strict';
+  // Default subscriber to easily add listeners with the on() method
+  const defaultSubscriber = async (eventName, ...args) => {
+    if (listeners.has(eventName)) {
+      for (const listener of listeners.get(eventName)) {
+        await listener(...args);
+      }
+    }
+  };
 
-const EventEmitter = require('events');
+  // Store of subscribers that will be called when an event is emitted
+  const subscribers = [defaultSubscriber];
 
-class EventHub extends EventEmitter {}
+  const eventHub = {
+    async emit(eventName, ...args) {
+      for (const subscriber of subscribers) {
+        await subscriber(eventName, ...args);
+      }
+    },
 
-/**
- * Expose a factory function instead of the class
- */
-module.exports = function createEventHub(opts) {
-  return new EventHub(opts);
+    subscribe(subscriber) {
+      subscribers.push(subscriber);
+
+      // Return a function to remove the subscriber
+      return () => {
+        eventHub.unsubscribe(subscriber);
+      };
+    },
+
+    unsubscribe(subscriber) {
+      subscribers.splice(subscribers.indexOf(subscriber), 1);
+    },
+
+    on(eventName, listener) {
+      if (!listeners.has(eventName)) {
+        listeners.set(eventName, [listener]);
+      } else {
+        listeners.get(eventName).push(listener);
+      }
+
+      // Return a function to remove the listener
+      return () => {
+        eventHub.off(eventName, listener);
+      };
+    },
+
+    off(eventName, listener) {
+      listeners.get(eventName).splice(listeners.get(eventName).indexOf(listener), 1);
+    },
+
+    once(eventName, listener) {
+      return eventHub.on(eventName, async (...args) => {
+        eventHub.off(eventName, listener);
+        return listener(...args);
+      });
+    },
+
+    destroy() {
+      listeners.clear();
+      subscribers.length = 0;
+      return this;
+    },
+  };
+
+  return {
+    ...eventHub,
+    removeListener: eventHub.off,
+    removeAllListeners: eventHub.destroy,
+    addListener: eventHub.on,
+  };
 };

package/lib/types/core/strapi/index.d.ts

@@ -378,6 +378,11 @@ export interface Strapi {
    */
   telemetry: any;
 
+  /**
+   * Used to access ctx from anywhere within the Strapi application
+   */
+  requestContext: any;
+
   /**
    * Strapi DB layer instance
    */

package/lib/types/factories.d.ts

@@ -30,7 +30,7 @@ type CollectionTypeRouterConfig = {
 
 type RouterConfig = {
   prefix?: string;
-  only: string[];
+  only?: string[];
   except?: string[];
   config: SingleTypeRouterConfig | CollectionTypeRouterConfig;
 };

package/lib/utils/ee.js

@@ -18,7 +18,7 @@ const internals = {};
 const features = {
   bronze: [],
   silver: [],
-  gold: ['sso'],
+  gold: ['sso', 'audit-logs'],
 };
 
 module.exports = ({ dir, logger = noLog }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.6.0-beta.1",
+  "version": "4.6.0-beta.2",
   "description": "An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite",
   "keywords": [
     "strapi",
@@ -80,19 +80,19 @@
   "dependencies": {
     "@koa/cors": "3.4.3",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.6.0-beta.1",
-    "@strapi/data-transfer": "4.6.0-beta.1",
-    "@strapi/database": "4.6.0-beta.1",
-    "@strapi/generate-new": "4.6.0-beta.1",
-    "@strapi/generators": "4.6.0-beta.1",
-    "@strapi/logger": "4.6.0-beta.1",
-    "@strapi/permissions": "4.6.0-beta.1",
-    "@strapi/plugin-content-manager": "4.6.0-beta.1",
-    "@strapi/plugin-content-type-builder": "4.6.0-beta.1",
-    "@strapi/plugin-email": "4.6.0-beta.1",
-    "@strapi/plugin-upload": "4.6.0-beta.1",
-    "@strapi/typescript-utils": "4.6.0-beta.1",
-    "@strapi/utils": "4.6.0-beta.1",
+    "@strapi/admin": "4.6.0-beta.2",
+    "@strapi/data-transfer": "4.6.0-beta.2",
+    "@strapi/database": "4.6.0-beta.2",
+    "@strapi/generate-new": "4.6.0-beta.2",
+    "@strapi/generators": "4.6.0-beta.2",
+    "@strapi/logger": "4.6.0-beta.2",
+    "@strapi/permissions": "4.6.0-beta.2",
+    "@strapi/plugin-content-manager": "4.6.0-beta.2",
+    "@strapi/plugin-content-type-builder": "4.6.0-beta.2",
+    "@strapi/plugin-email": "4.6.0-beta.2",
+    "@strapi/plugin-upload": "4.6.0-beta.2",
+    "@strapi/typescript-utils": "4.6.0-beta.2",
+    "@strapi/utils": "4.6.0-beta.2",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -141,5 +141,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "2c0bcabdf0bf2a269fed50c6f23ba777845968a0"
+  "gitHead": "b852090f931cd21868c4016f24db2f9fdfc7a7ab"
 }

package/lib/commands/utils/index.js

@@ -1,20 +0,0 @@
-'use strict';
-
-const bytesPerKb = 1024;
-const sizes = ['B ', 'KB', 'MB', 'GB', 'TB', 'PB'];
-
-const readableBytes = (bytes, decimals = 1, padStart = 0) => {
-  if (!bytes) {
-    return '0';
-  }
-  const i = Math.floor(Math.log(bytes) / Math.log(bytesPerKb));
-  const result = `${parseFloat((bytes / bytesPerKb ** i).toFixed(decimals))} ${sizes[i].padStart(
-    2
-  )}`;
-
-  return result.padStart(padStart);
-};
-
-module.exports = {
-  readableBytes,
-};