@strapi/strapi 4.6.0-beta.1 → 4.6.0

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/loaders/plugins/index.js

@@ -85,7 +85,15 @@ const loadPlugins = async (strapi) => {
   for (const pluginName of Object.keys(enabledPlugins)) {
     const enabledPlugin = enabledPlugins[pluginName];
 
-    const serverEntrypointPath = join(enabledPlugin.pathToPlugin, 'strapi-server.js');
+    let serverEntrypointPath;
+
+    try {
+      serverEntrypointPath = join(enabledPlugin.pathToPlugin, 'strapi-server.js');
+    } catch (e) {
+      throw new Error(
+        `Error loading the plugin ${pluginName} because ${pluginName} is not installed. Please either install the plugin or remove it's configuration.`
+      );
+    }
 
     // only load plugins with a server entrypoint
     if (!(await fse.pathExists(serverEntrypointPath))) {

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

@@ -43,9 +43,10 @@ const createComponents = async (uid, data) => {
           throw new Error('Expected an array to create repeatable component');
         }
 
-        const components = await Promise.all(
-          componentValue.map((value) => createComponent(componentUID, value))
-        );
+        const components = [];
+        for (const value of componentValue) {
+          components.push(await createComponent(componentUID, value));
+        }
 
         componentBody[attributeName] = components.map(({ id }) => {
           return {
@@ -77,18 +78,19 @@ const createComponents = async (uid, data) => {
         throw new Error('Expected an array to create repeatable component');
       }
 
-      componentBody[attributeName] = await Promise.all(
-        dynamiczoneValues.map(async (value) => {
-          const { id } = await createComponent(value.__component, value);
-          return {
-            id,
-            __component: value.__component,
-            __pivot: {
-              field: attributeName,
-            },
-          };
-        })
-      );
+      const dynamicZoneData = [];
+      for (const value of dynamiczoneValues) {
+        const { id } = await createComponent(value.__component, value);
+        dynamicZoneData.push({
+          id,
+          __component: value.__component,
+          __pivot: {
+            field: attributeName,
+          },
+        });
+      }
+
+      componentBody[attributeName] = dynamicZoneData;
 
       continue;
     }
@@ -137,9 +139,10 @@ const updateComponents = async (uid, entityToUpdate, data) => {
           throw new Error('Expected an array to create repeatable component');
         }
 
-        const components = await Promise.all(
-          componentValue.map((value) => updateOrCreateComponent(componentUID, value))
-        );
+        const components = [];
+        for (const value of componentValue) {
+          components.push(await updateOrCreateComponent(componentUID, value));
+        }
 
         componentBody[attributeName] = components.filter(_.negate(_.isNil)).map(({ id }) => {
           return {
@@ -173,19 +176,19 @@ const updateComponents = async (uid, entityToUpdate, data) => {
         throw new Error('Expected an array to create repeatable component');
       }
 
-      componentBody[attributeName] = await Promise.all(
-        dynamiczoneValues.map(async (value) => {
-          const { id } = await updateOrCreateComponent(value.__component, value);
+      const dynamicZoneData = [];
+      for (const value of dynamiczoneValues) {
+        const { id } = await updateOrCreateComponent(value.__component, value);
+        dynamicZoneData.push({
+          id,
+          __component: value.__component,
+          __pivot: {
+            field: attributeName,
+          },
+        });
+      }
 
-          return {
-            id,
-            __component: value.__component,
-            __pivot: {
-              field: attributeName,
-            },
-          };
-        })
-      );
+      componentBody[attributeName] = dynamicZoneData;
 
       continue;
     }
@@ -287,14 +290,14 @@ const deleteComponents = async (uid, entityToDelete, { loadComponents = true } =
 
       if (attribute.type === 'component') {
         const { component: componentUID } = attribute;
-        await Promise.all(
-          _.castArray(value).map((subValue) => deleteComponent(componentUID, subValue))
-        );
+        for (const subValue of _.castArray(value)) {
+          await deleteComponent(componentUID, subValue);
+        }
       } else {
         // delete dynamic zone components
-        await Promise.all(
-          _.castArray(value).map((subValue) => deleteComponent(subValue.__component, subValue))
-        );
+        for (const subValue of _.castArray(value)) {
+          await deleteComponent(subValue.__component, subValue);
+        }
       }
 
       continue;

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,11 +60,17 @@ 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);
 
     eventHub.emit(event, {
       model: model.modelName,
+      uid: model.uid,
       entry: sanitizedEntity,
     });
   },

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/index.js

@@ -5,12 +5,8 @@
  * You can learn more at https://docs.strapi.io/developer-docs/latest/getting-started/usage-information.html
  */
 
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
 const { scheduleJob } = require('node-schedule');
 
-const ee = require('../../utils/ee');
 const wrapWithRateLimit = require('./rate-limiter');
 const createSender = require('./sender');
 const createMiddleware = require('./middleware');
@@ -46,41 +42,14 @@ const createTelemetryInstance = (strapi) => {
         strapi.server.use(createMiddleware({ sendEvent }));
       }
     },
-    bootstrap() {
-      if (strapi.EE === true && ee.isEE === true) {
-        const pingDisabled =
-          isTruthy(process.env.STRAPI_LICENSE_PING_DISABLED) && ee.licenseInfo.type === 'gold';
 
-        const sendLicenseCheck = () => {
-          return sendEvent(
-            'didCheckLicense',
-            {
-              groupProperties: {
-                licenseInfo: {
-                  ...ee.licenseInfo,
-                  projectHash: hashProject(strapi),
-                  dependencyHash: hashDep(strapi),
-                },
-              },
-            },
-            {
-              headers: { 'x-strapi-project': 'enterprise' },
-            }
-          );
-        };
+    bootstrap() {},
 
-        if (!pingDisabled) {
-          const licenseCron = scheduleJob('0 0 0 * * 7', () => sendLicenseCheck());
-          crons.push(licenseCron);
-
-          sendLicenseCheck();
-        }
-      }
-    },
     destroy() {
-      // clear open handles
+      // Clear open handles
       crons.forEach((cron) => cron.cancel());
     },
+
     async send(event, payload) {
       if (isDisabled) return true;
       return sendEvent(event, payload);
@@ -88,24 +57,4 @@ const createTelemetryInstance = (strapi) => {
   };
 };
 
-const hash = (str) => crypto.createHash('sha256').update(str).digest('hex');
-
-const hashProject = (strapi) =>
-  hash(`${strapi.config.get('info.name')}${strapi.config.get('info.description')}`);
-
-const hashDep = (strapi) => {
-  const depStr = JSON.stringify(strapi.config.info.dependencies);
-  const readmePath = path.join(strapi.dirs.app.root, 'README.md');
-
-  try {
-    if (fs.existsSync(readmePath)) {
-      return hash(`${depStr}${fs.readFileSync(readmePath)}`);
-    }
-  } catch (err) {
-    return hash(`${depStr}`);
-  }
-
-  return hash(`${depStr}`);
-};
-
 module.exports = createTelemetryInstance;

package/lib/services/metrics/sender.js

@@ -8,7 +8,6 @@ const fetch = require('node-fetch');
 const ciEnv = require('ci-info');
 const { isUsingTypeScriptSync } = require('@strapi/typescript-utils');
 const { env } = require('@strapi/utils');
-const ee = require('../../utils/ee');
 const machineID = require('../../utils/machine-id');
 const { generateAdminUserHash } = require('./admin-user-hash');
 
@@ -37,7 +36,6 @@ const addPackageJsonStrapiMetadata = (metadata, strapi) => {
 module.exports = (strapi) => {
   const { uuid } = strapi.config;
   const deviceId = machineID();
-  const isEE = strapi.EE === true && ee.isEE === true;
 
   const serverRootPath = strapi.dirs.app.root;
   const adminRootPath = path.join(strapi.dirs.app.root, 'src', 'admin');
@@ -55,7 +53,6 @@ module.exports = (strapi) => {
     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,
@@ -77,6 +74,7 @@ module.exports = (strapi) => {
         userProperties: userId ? { ...anonymousUserProperties, ...payload.userProperties } : {},
         groupProperties: {
           ...anonymousGroupProperties,
+          projectType: strapi.EE ? 'Enterprise' : 'Community',
           ...payload.groupProperties,
         },
       }),

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/cron.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { isEmpty, negate } = require('lodash/fp');
+
+const INTEGER_REGEX = /^\d+$/;
+const STEP_REGEX = /^\*\/\d+$/;
+const COMPONENTS = [
+  { limit: 60, zeroBasedIndices: true, functionName: 'getSeconds' },
+  { limit: 60, zeroBasedIndices: true, functionName: 'getMinutes' },
+  { limit: 24, zeroBasedIndices: true, functionName: 'getHours' },
+  { limit: 31, zeroBasedIndices: false, functionName: 'getDate' },
+  { limit: 12, zeroBasedIndices: false, functionName: 'getMonth' },
+  { limit: 7, zeroBasedIndices: true, functionName: 'getDay' },
+];
+
+const shift = (component, index, date) => {
+  if (component === '*') {
+    return '*';
+  }
+
+  const { limit, zeroBasedIndices, functionName } = COMPONENTS[index];
+  const offset = +!zeroBasedIndices;
+  const currentValue = date[functionName]();
+
+  if (INTEGER_REGEX.test(component)) {
+    return ((Number.parseInt(component, 10) + currentValue) % limit) + offset;
+  }
+
+  if (STEP_REGEX.test(component)) {
+    const [, step] = component.split('/');
+    const frequency = Math.floor(limit / step);
+    const list = Array.from({ length: frequency }, (_, index) => index * step);
+    return list.map((value) => ((value + currentValue) % limit) + offset).sort((a, b) => a - b);
+  }
+
+  // Unsupported syntax
+  return component;
+};
+
+/**
+ * Simulate an interval by shifting a cron expression using the specified date.
+ * @param {string} rule A cron expression you want to shift.
+ * @param {Date} date The date that's gonna be used as the start of the "interval", it defaults to now.
+ * @returns The shifted cron expression.
+ */
+const shiftCronExpression = (rule, date = new Date()) => {
+  const components = rule.trim().split(' ').filter(negate(isEmpty));
+  const secondsIncluded = components.length === 6;
+  return components
+    .map((component, index) => shift(component, secondsIncluded ? index : index + 1, date))
+    .join(' ');
+};
+
+module.exports = {
+  shiftCronExpression,
+};