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

package/lib/commands/transfer/utils.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const chalk = require('chalk');
+const Table = require('cli-table3');
+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);
+};
+
+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();
+};
+
+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,
+  DEFAULT_IGNORED_CONTENT_TYPES,
+  createStrapiInstance,
+  excludeOption,
+  onlyOption,
+  validateExcludeOnly,
+};

package/lib/commands/utils/commander.js

@@ -0,0 +1,136 @@
+'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;
+  };
+};
+
+/**
+ * argParser: Parse a string as a URL object
+ */
+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}`);
+  }
+};
+
+/**
+ * hook: if encrypt==true and key not provided, prompt for it
+ */
+const promptEncryptionKey = async (thisCommand) => {
+  const opts = thisCommand.opts();
+
+  if (!opts.encrypt && opts.key) {
+    return exitWith(1, 'Key may not be present unless encryption is used');
+  }
+
+  // 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) {
+      return exitWith(1, 'Failed to get encryption key');
+    }
+    if (!opts.key) {
+      return exitWith(1, 'Failed to get encryption key');
+    }
+  }
+};
+
+/**
+ * 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 (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',
+        message,
+        name: `confirm`,
+        default: false,
+      },
+    ]);
+    if (!answers.confirm) {
+      exitWith(0);
+    }
+  };
+};
+
+const forceOption = new Option(
+  '-f, --force',
+  `Automatically answer "yes" to all prompts, including potentially destructive requests, and run non-interactively.`
+);
+
+module.exports = {
+  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/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-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/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;