@strapi/strapi 4.6.0-alpha.1 → 4.6.0-beta.1

package/bin/strapi.js

@@ -5,13 +5,16 @@
 // 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 } = require('../lib/commands/utils/commander');
 
 const checkCwdIsStrapiApp = (name) => {
   const logErrorAndExit = () => {
@@ -255,4 +258,68 @@ program
   .option('-s, --silent', `Run the generation silently, without any output`, false)
   .action(getLocalScript('ts/generate-types'));
 
+// `$ strapi export`
+program
+  .command('export')
+  .description('Export data from Strapi to file')
+  .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)'))
+  .allowExcessArguments(false)
+  .hook('preAction', promptEncryptionKey)
+  .action(getLocalScript('transfer/export'));
+
+// `$ strapi import`
+program
+  .command('import')
+  .description('Import data from file to Strapi')
+  .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'
+    )
+  )
+  .allowExcessArguments(false)
+  .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) {
+          console.log('No key entered, aborting import.');
+          process.exit(0);
+        }
+        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.destroy();
+    this.eventHub.removeAllListeners();
 
     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,161 @@
+'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');
+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
+    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 export...`);
+
+    const progress = engine.progress.stream;
+
+    const telemetryPayload = (/* 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));
+    });
+
+    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)}`);
+    process.exit(0);
+  } catch (e) {
+    logger.error('Export process failed unexpectedly:', e.toString());
+    process.exit(1);
+  }
+};
+
+/**
+ * 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,152 @@
+'use strict';
+
+const {
+  createLocalFileSourceProvider,
+  createLocalStrapiDestinationProvider,
+  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');
+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;
+    },
+    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,
+    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);
+
+  try {
+    logger.info('Starting import...');
+
+    const progress = engine.progress.stream;
+    const telemetryPayload = (/* payload */) => {
+      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));
+    });
+
+    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) {
+    logger.error('Import process failed unexpectedly:');
+    logger.error(e);
+    process.exit(1);
+  }
+};
+
+/**
+ * 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/utils.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const { readableBytes } = require('../utils');
+const strapi = require('../../index');
+
+const pad = (n) => {
+  return (n < 10 ? '0' : '') + String(n);
+};
+
+const yyyymmddHHMMSS = () => {
+  const date = new Date();
+
+  return (
+    date.getFullYear() +
+    pad(date.getMonth() + 1) +
+    pad(date.getDate()) +
+    pad(date.getHours()) +
+    pad(date.getMinutes()) +
+    pad(date.getSeconds())
+  );
+};
+
+const getDefaultExportName = () => {
+  return `export_${yyyymmddHHMMSS()}`;
+};
+
+const buildTransferTable = (resultData) => {
+  // Build pretty table
+  const table = new Table({
+    head: ['Type', 'Count', 'Size'].map((text) => chalk.bold.blue(text)),
+  });
+
+  let totalBytes = 0;
+  let totalItems = 0;
+  Object.keys(resultData).forEach((key) => {
+    const item = resultData[key];
+
+    table.push([
+      { hAlign: 'left', content: chalk.bold(key) },
+      { hAlign: 'right', content: item.count },
+      { hAlign: 'right', content: `${readableBytes(item.bytes, 1, 11)} ` },
+    ]);
+    totalBytes += item.bytes;
+    totalItems += item.count;
+
+    if (item.aggregates) {
+      Object.keys(item.aggregates)
+        .sort()
+        .forEach((subkey) => {
+          const subitem = item.aggregates[subkey];
+
+          table.push([
+            { hAlign: 'left', content: `-- ${chalk.bold.grey(subkey)}` },
+            { hAlign: 'right', content: chalk.grey(subitem.count) },
+            { hAlign: 'right', content: chalk.grey(`(${readableBytes(subitem.bytes, 1, 11)})`) },
+          ]);
+        });
+    }
+  });
+  table.push([
+    { hAlign: 'left', content: chalk.bold.green('Total') },
+    { hAlign: 'right', content: chalk.bold.green(totalItems) },
+    { hAlign: 'right', content: `${chalk.bold.green(readableBytes(totalBytes, 1, 11))} ` },
+  ]);
+
+  return table;
+};
+
+const DEFAULT_IGNORED_CONTENT_TYPES = [
+  'admin::permission',
+  'admin::user',
+  'admin::role',
+  'admin::api-token',
+  'admin::api-token-permission',
+];
+
+const createStrapiInstance = async (logLevel = 'error') => {
+  const appContext = await strapi.compile();
+  const app = strapi(appContext);
+
+  app.log.level = logLevel;
+
+  return app.load();
+};
+
+module.exports = {
+  buildTransferTable,
+  getDefaultExportName,
+  yyyymmddHHMMSS,
+  DEFAULT_IGNORED_CONTENT_TYPES,
+  createStrapiInstance,
+};

package/lib/commands/utils/commander.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const inquirer = require('inquirer');
+
+/**
+ * argsParser: Parse a comma-delimited string as an array
+ */
+const parseInputList = (value) => {
+  return value.split(',');
+};
+
+/**
+ * hook: if encrypt==true and key not provided, prompt for it
+ */
+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);
+  }
+
+  // if encrypt==true but we have no key, prompt for it
+  if (opts.encrypt && !(opts.key && opts.key.length > 0)) {
+    try {
+      const answers = await inquirer.prompt([
+        {
+          type: 'password',
+          message: 'Please enter an encryption key',
+          name: 'key',
+          validate(key) {
+            if (key.length > 0) return true;
+
+            return 'Key must be present when using the encrypt option';
+          },
+        },
+      ]);
+      opts.key = answers.key;
+    } catch (e) {
+      console.error('Failed to get encryption key');
+      process.exit(1);
+    }
+    if (!opts.key) {
+      console.error('Failed to get encryption key');
+      process.exit(1);
+    }
+  }
+};
+
+/**
+ * hook: require a confirmation message to be accepted
+ */
+const confirmMessage = (message) => {
+  return async () => {
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        message,
+        name: `confirm`,
+        default: false,
+      },
+    ]);
+    if (!answers.confirm) {
+      process.exit(0);
+    }
+  };
+};
+
+module.exports = {
+  parseInputList,
+  promptEncryptionKey,
+  confirmMessage,
+};

package/lib/commands/utils/index.js

@@ -0,0 +1,20 @@
+'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,
+};

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

@@ -1,7 +1,7 @@
 'use strict';
 
 const _ = require('lodash');
-const { has, prop, omit, toString } = require('lodash/fp');
+const { has, prop, omit, toString, pipe, assign } = require('lodash/fp');
 
 const { contentTypes: contentTypesUtils } = require('@strapi/utils');
 const { ApplicationError } = require('@strapi/utils').errors;
@@ -311,10 +311,16 @@ const createComponent = async (uid, data) => {
   const model = strapi.getModel(uid);
 
   const componentData = await createComponents(uid, data);
+  const transform = pipe(
+    // Make sure we don't save the component with a pre-defined ID
+    omit('id'),
+    // Remove the component data from the original data object ...
+    (payload) => omitComponentData(model, payload),
+    // ... and assign the newly created component instead
+    assign(componentData)
+  );
 
-  return strapi.query(uid).create({
-    data: Object.assign(omitComponentData(model, data), componentData),
-  });
+  return strapi.query(uid).create({ data: transform(data) });
 };
 
 // components can have nested compos so this must be recursive

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

@@ -293,40 +293,48 @@ const buildRelationsStore = ({ uid, data }) => {
         break;
       }
       case 'component': {
-        return castArray(value).reduce(
-          (relationsStore, componentValue) =>
-            mergeWith(
-              relationsStore,
-              buildRelationsStore({
-                uid: attribute.component,
-                data: componentValue,
-              }),
-              (objValue, srcValue) => {
-                if (isArray(objValue)) {
-                  return objValue.concat(srcValue);
-                }
+        return castArray(value).reduce((relationsStore, componentValue) => {
+          if (!attribute.component) {
+            throw new ValidationError(
+              `Cannot build relations store from component, component identifier is undefined`
+            );
+          }
+
+          return mergeWith(
+            relationsStore,
+            buildRelationsStore({
+              uid: attribute.component,
+              data: componentValue,
+            }),
+            (objValue, srcValue) => {
+              if (isArray(objValue)) {
+                return objValue.concat(srcValue);
               }
-            ),
-          result
-        );
+            }
+          );
+        }, result);
       }
       case 'dynamiczone': {
-        return value.reduce(
-          (relationsStore, dzValue) =>
-            mergeWith(
-              relationsStore,
-              buildRelationsStore({
-                uid: dzValue.__component,
-                data: dzValue,
-              }),
-              (objValue, srcValue) => {
-                if (isArray(objValue)) {
-                  return objValue.concat(srcValue);
-                }
+        return value.reduce((relationsStore, dzValue) => {
+          if (!dzValue.__component) {
+            throw new ValidationError(
+              `Cannot build relations store from dynamiczone, component identifier is undefined`
+            );
+          }
+
+          return mergeWith(
+            relationsStore,
+            buildRelationsStore({
+              uid: dzValue.__component,
+              data: dzValue,
+            }),
+            (objValue, srcValue) => {
+              if (isArray(objValue)) {
+                return objValue.concat(srcValue);
               }
-            ),
-          result
-        );
+            }
+          );
+        }, result);
       }
       default:
         break;

package/lib/services/event-hub.js

@@ -1,78 +1,16 @@
-'use strict';
-
 /**
  * The event hub is Strapi's event control center.
  */
-module.exports = function createEventHub() {
-  const listeners = new Map();
-
-  // 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);
-      }
-    }
-  };
-
-  // Store of subscribers that will be called when an event is emitted
-  const subscribers = [defaultSubscriber];
-
-  const eventHub = {
-    async emit(eventName, ...args) {
-      for (const subscriber of subscribers) {
-        await subscriber(eventName, ...args);
-      }
-    },
-
-    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, []);
-      }
-
-      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);
-    },
+'use strict';
 
-    once(eventName, listener) {
-      return eventHub.on(eventName, async (...args) => {
-        eventHub.off(eventName, listener);
-        return listener(...args);
-      });
-    },
+const EventEmitter = require('events');
 
-    destroy() {
-      listeners.clear();
-      subscribers.length = 0;
-      return this;
-    },
-  };
+class EventHub extends EventEmitter {}
 
-  return {
-    ...eventHub,
-    removeListener: eventHub.off,
-    removeAllListeners: eventHub.destroy,
-    addListener: eventHub.on,
-  };
+/**
+ * Expose a factory function instead of the class
+ */
+module.exports = function createEventHub(opts) {
+  return new EventHub(opts);
 };

package/lib/services/metrics/admin-user-hash.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const crypto = require('crypto');
+
+/**
+ * Generate an admin user hash
+ *
+ * @param {Strapi.Strapi} strapi
+ * @returns {string}
+ */
+const generateAdminUserHash = (strapi) => {
+  const ctx = strapi?.requestContext?.get();
+  if (!ctx?.state?.user) {
+    return '';
+  }
+  return crypto.createHash('sha256').update(ctx.state.user.email).digest('hex');
+};
+
+module.exports = {
+  generateAdminUserHash,
+};

package/lib/services/metrics/index.js

@@ -55,10 +55,12 @@ const createTelemetryInstance = (strapi) => {
           return sendEvent(
             'didCheckLicense',
             {
-              licenseInfo: {
-                ...ee.licenseInfo,
-                projectHash: hashProject(strapi),
-                dependencyHash: hashDep(strapi),
+              groupProperties: {
+                licenseInfo: {
+                  ...ee.licenseInfo,
+                  projectHash: hashProject(strapi),
+                  dependencyHash: hashDep(strapi),
+                },
               },
             },
             {

package/lib/services/metrics/middleware.js

@@ -19,7 +19,7 @@ const createMiddleware = ({ sendEvent }) => {
 
       // Send max. 1000 events per day.
       if (_state.counter < 1000) {
-        sendEvent('didReceiveRequest', { url: ctx.request.url });
+        sendEvent('didReceiveRequest', { eventProperties: { url: ctx.request.url } });
 
         // Increase counter.
         _state.counter += 1;

package/lib/services/metrics/sender.js

@@ -10,7 +10,7 @@ const { isUsingTypeScriptSync } = require('@strapi/typescript-utils');
 const { env } = require('@strapi/utils');
 const ee = require('../../utils/ee');
 const machineID = require('../../utils/machine-id');
-const stringifyDeep = require('./stringify-deep');
+const { generateAdminUserHash } = require('./admin-user-hash');
 
 const defaultQueryOpts = {
   timeout: 1000,
@@ -42,41 +42,49 @@ module.exports = (strapi) => {
   const serverRootPath = strapi.dirs.app.root;
   const adminRootPath = path.join(strapi.dirs.app.root, 'src', 'admin');
 
-  const anonymousMetadata = {
+  const anonymousUserProperties = {
     environment: strapi.config.environment,
     os: os.type(),
     osPlatform: os.platform(),
     osArch: os.arch(),
     osRelease: os.release(),
     nodeVersion: process.versions.node,
+  };
+
+  const anonymousGroupProperties = {
     docker: process.env.DOCKER || isDocker(),
     isCI: ciEnv.isCI,
     version: strapi.config.get('info.strapi'),
     projectType: isEE ? 'Enterprise' : 'Community',
     useTypescriptOnServer: isUsingTypeScriptSync(serverRootPath),
     useTypescriptOnAdmin: isUsingTypeScriptSync(adminRootPath),
+    projectId: uuid,
     isHostedOnStrapiCloud: env('STRAPI_HOSTING', null) === 'strapi.cloud',
   };
 
-  addPackageJsonStrapiMetadata(anonymousMetadata, strapi);
+  addPackageJsonStrapiMetadata(anonymousGroupProperties, strapi);
 
   return async (event, payload = {}, opts = {}) => {
+    const userId = generateAdminUserHash(strapi);
+
     const reqParams = {
       method: 'POST',
       body: JSON.stringify({
         event,
-        uuid,
+        userId,
         deviceId,
-        properties: stringifyDeep({
-          ...payload,
-          ...anonymousMetadata,
-        }),
+        eventProperties: payload.eventProperties,
+        userProperties: userId ? { ...anonymousUserProperties, ...payload.userProperties } : {},
+        groupProperties: {
+          ...anonymousGroupProperties,
+          ...payload.groupProperties,
+        },
       }),
       ..._.merge({}, defaultQueryOpts, opts),
     };
 
     try {
-      const res = await fetch(`${ANALYTICS_URI}/track`, reqParams);
+      const res = await fetch(`${ANALYTICS_URI}/api/v2/track`, reqParams);
       return res.ok;
     } catch (err) {
       return false;

package/lib/types/core/attributes/relation.d.ts

@@ -3,7 +3,7 @@ import { Attribute, ConfigurableOption, PrivateOption } from './base';
 import { GetAttributesByType, GetAttributesValues } from './utils';
 
 export type BasicRelationsType = 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany';
-export type PolymorphicRelationsType =  'morphToOne' | 'morphToMany' | 'morphOne' | 'morphMany';
+export type PolymorphicRelationsType = 'morphToOne' | 'morphToMany' | 'morphOne' | 'morphMany';
 export type RelationsType = BasicRelationsType | PolymorphicRelationsType;
 
 export interface BasicRelationAttributeProperties<
@@ -17,16 +17,14 @@ export interface BasicRelationAttributeProperties<
   mappedBy?: RelationsKeysFromTo<T, S>;
 }
 
-export interface PolymorphicRelationAttributeProperties<
-  R extends RelationsType,
-> {
+export interface PolymorphicRelationAttributeProperties<R extends RelationsType> {
   relation: R;
 }
 
 export type RelationAttribute<
   S extends SchemaUID,
   R extends RelationsType,
-  T extends R extends PolymorphicRelationsType ? never: SchemaUID = never
+  T extends R extends PolymorphicRelationsType ? never : SchemaUID = never
 > = Attribute<'relation'> &
   // Properties
   (R extends BasicRelationsType
@@ -34,22 +32,21 @@ export type RelationAttribute<
     : PolymorphicRelationAttributeProperties<R>) &
   // Options
   ConfigurableOption &
-  PrivateOption
+  PrivateOption;
 
 export type RelationsKeysFromTo<
   TTarget extends SchemaUID,
   TSource extends SchemaUID
 > = keyof PickRelationsFromTo<TTarget, TSource>;
 
-export type PickRelationsFromTo<TTarget extends SchemaUID, TSource extends SchemaUID> = GetAttributesByType<
-  TTarget,
-  'relation',
-  { target: TSource }
->;
+export type PickRelationsFromTo<
+  TTarget extends SchemaUID,
+  TSource extends SchemaUID
+> = GetAttributesByType<TTarget, 'relation', { target: TSource }>;
 
 export type RelationPluralityModifier<
   TRelation extends RelationsType,
-  TValue extends Object
+  TValue extends Record<string, unknown>
 > = TRelation extends `${string}Many` ? TValue[] : TValue;
 
 export type RelationValue<

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

@@ -1,5 +1,5 @@
 import { Attribute, ComponentAttribute } from '../attributes';
-import { KeysBy, StringRecord } from '../../utils';
+import { KeysBy, SchemaUID, StringRecord } from '../../utils';
 
 /**
  * Literal union type representing the possible natures of a content type
@@ -98,6 +98,11 @@ export interface PluginOptions {}
 export interface ContentTypeSchema extends Schema {
   modelType: 'contentType';
 
+  /**
+   * Unique identifier of the schema
+   */
+  uid: SchemaUID;
+
   /**
    * Determine the type of the content type (single-type or collection-type)
    */

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

@@ -2,8 +2,8 @@ import type Koa from 'koa';
 import { Database } from '@strapi/database';
 
 import type { StringMap } from './utils';
-import type { GenericController } from '../../../core-api/controller'
-import type { GenericService } from '../../../core-api/service'
+import type { GenericController } from '../../../core-api/controller';
+import type { GenericService } from '../../../core-api/service';
 
 // TODO move custom fields types to a separate file
 interface CustomFieldServerOptions {
@@ -92,9 +92,16 @@ export interface Strapi {
    */
   contentType(uid: string): any;
 
+  /**
+   * Getter for the Strapi component container
+   *
+   * It returns all the registered components
+   */
+  readonly components: any;
+
   /**
    * The custom fields registry
-   * 
+   *
    * It returns the custom fields interface
    */
   readonly customFields: CustomFields;
@@ -361,7 +368,6 @@ export interface Strapi {
    */
   log: any;
 
-
   /**
    * Used to manage cron within Strapi
    */

package/lib/types/factories.d.ts

@@ -1,8 +1,8 @@
-import { Service,GenericService } from '../core-api/service';
+import { Service, GenericService } from '../core-api/service';
 import { Controller, GenericController } from '../core-api/controller';
 import { Middleware } from '../middlewares';
 import { Policy } from '../core/registries/policies';
-import { Strapi } from '@strapi/strapi';
+import { Strapi } from './core/strapi';
 
 type ControllerConfig<T extends Controller = Controller> = T;
 

package/lib/utils/success.js

@@ -17,7 +17,7 @@ try {
     process.env.npm_config_global === 'true' ||
     JSON.parse(process.env.npm_config_argv).original.includes('global')
   ) {
-    fetch('https://analytics.strapi.io/track', {
+    fetch('https://analytics.strapi.io/api/v2/track', {
       method: 'POST',
       body: JSON.stringify({
         event: 'didInstallStrapi',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.6.0-alpha.1",
+  "version": "4.6.0-beta.1",
   "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,18 +80,19 @@
   "dependencies": {
     "@koa/cors": "3.4.3",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.6.0-alpha.1",
-    "@strapi/database": "4.6.0-alpha.1",
-    "@strapi/generate-new": "4.6.0-alpha.1",
-    "@strapi/generators": "4.6.0-alpha.1",
-    "@strapi/logger": "4.6.0-alpha.1",
-    "@strapi/permissions": "4.6.0-alpha.1",
-    "@strapi/plugin-content-manager": "4.6.0-alpha.1",
-    "@strapi/plugin-content-type-builder": "4.6.0-alpha.1",
-    "@strapi/plugin-email": "4.6.0-alpha.1",
-    "@strapi/plugin-upload": "4.6.0-alpha.1",
-    "@strapi/typescript-utils": "4.6.0-alpha.1",
-    "@strapi/utils": "4.6.0-alpha.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",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -100,7 +101,7 @@
     "cli-table3": "0.6.2",
     "commander": "8.2.0",
     "configstore": "5.0.1",
-    "debug": "4.3.2",
+    "debug": "4.3.4",
     "delegates": "1.0.0",
     "dotenv": "10.0.0",
     "execa": "5.1.1",
@@ -126,7 +127,7 @@
     "open": "8.4.0",
     "ora": "5.4.1",
     "package-json": "7.0.0",
-    "qs": "6.10.1",
+    "qs": "6.11.0",
     "resolve-cwd": "3.0.0",
     "semver": "7.3.8",
     "statuses": "2.0.1",
@@ -140,5 +141,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "9171c48104548f5f6da21abf2a8098009f1a40e9"
+  "gitHead": "2c0bcabdf0bf2a269fed50c6f23ba777845968a0"
 }