@strapi/strapi 4.0.0-beta.0

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

@@ -0,0 +1,145 @@
+'use strict';
+
+const { pick, pipe, isNil } = require('lodash/fp');
+
+const {
+  convertSortQueryParams,
+  convertLimitQueryParams,
+  convertStartQueryParams,
+  convertPopulateQueryParams,
+  convertFiltersQueryParams,
+  convertFieldsQueryParams,
+} = require('@strapi/utils/lib/convert-query-params');
+
+const { contentTypes: contentTypesUtils } = require('@strapi/utils');
+
+const { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;
+
+// TODO: to remove once the front is migrated
+const convertOldQuery = params => {
+  const query = {};
+
+  Object.keys(params).forEach(key => {
+    if (key.startsWith('_')) {
+      query[key.slice(1)] = params[key];
+    } else {
+      query[key] = params[key];
+    }
+  });
+
+  return query;
+};
+
+const transformCommonParams = (params = {}) => {
+  const { _q, sort, filters, _where, fields, populate, ...query } = params;
+
+  if (_q) {
+    query._q = _q;
+  }
+
+  if (sort) {
+    query.orderBy = convertSortQueryParams(sort);
+  }
+
+  if (filters) {
+    query.where = convertFiltersQueryParams(filters);
+  }
+
+  if (_where) {
+    query.where = {
+      $and: [_where].concat(query.where || []),
+    };
+  }
+
+  if (fields) {
+    query.select = convertFieldsQueryParams(fields);
+  }
+
+  if (populate) {
+    query.populate = convertPopulateQueryParams(populate);
+  }
+
+  return { ...convertOldQuery(query), ...query };
+};
+
+const transformPaginationParams = (params = {}) => {
+  const { page, pageSize, start, limit, ...query } = params;
+
+  const isPagePagination = !isNil(page) || !isNil(pageSize);
+  const isOffsetPagination = !isNil(start) || !isNil(limit);
+
+  if (isPagePagination && isOffsetPagination) {
+    throw new Error(
+      'Invalid pagination attributes. You cannot use page and offset pagination in the same query'
+    );
+  }
+
+  if (page) {
+    query.page = Number(page);
+  }
+
+  if (pageSize) {
+    query.pageSize = Number(pageSize);
+  }
+
+  if (start) {
+    query.offset = convertStartQueryParams(start);
+  }
+
+  if (limit) {
+    query.limit = convertLimitQueryParams(limit);
+  }
+
+  return { ...convertOldQuery(query), ...query };
+};
+
+const transformPublicationStateParams = uid => (params = {}) => {
+  const contentType = strapi.getModel(uid);
+
+  if (!contentType) {
+    return params;
+  }
+
+  const { publicationState, ...query } = params;
+
+  if (publicationState && contentTypesUtils.hasDraftAndPublish(contentType)) {
+    const { publicationState = 'live' } = params;
+
+    const liveClause = {
+      [PUBLISHED_AT_ATTRIBUTE]: {
+        $notNull: true,
+      },
+    };
+
+    if (publicationState === 'live') {
+      query.where = {
+        $and: [liveClause].concat(query.where || []),
+      };
+
+      // TODO: propagate nested publicationState filter somehow
+    }
+  }
+
+  return { ...convertOldQuery(query), ...query };
+};
+
+const pickSelectionParams = pick(['fields', 'populate']);
+
+const transformParamsToQuery = (uid, params) => {
+  return pipe(
+    // _q, _where, filters, etc...
+    transformCommonParams,
+    // page, pageSize, start, limit
+    transformPaginationParams,
+    // publicationState
+    transformPublicationStateParams(uid)
+  )(params);
+};
+
+module.exports = {
+  transformCommonParams,
+  transformPublicationStateParams,
+  transformPaginationParams,
+  transformParamsToQuery,
+  pickSelectionParams,
+};

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

@@ -0,0 +1,187 @@
+/**
+ * Entity validator
+ * Module that will validate input data for entity creation or edition
+ */
+'use strict';
+
+const { has, assoc, prop } = require('lodash/fp');
+const strapiUtils = require('@strapi/utils');
+const validators = require('./validators');
+
+const { yup, formatYupErrors } = strapiUtils;
+const { isMediaAttribute, isScalarAttribute, getWritableAttributes } = strapiUtils.contentTypes;
+
+const addMinMax = (attr, validator, data) => {
+  if (Number.isInteger(attr.min) && (attr.required || (Array.isArray(data) && data.length > 0))) {
+    validator = validator.min(attr.min);
+  }
+  if (Number.isInteger(attr.max)) {
+    validator = validator.max(attr.max);
+  }
+  return validator;
+};
+
+const addRequiredValidation = createOrUpdate => (required, validator) => {
+  if (required) {
+    if (createOrUpdate === 'creation') {
+      validator = validator.notNil();
+    } else if (createOrUpdate === 'update') {
+      validator = validator.notNull();
+    }
+  } else {
+    validator = validator.nullable();
+  }
+  return validator;
+};
+
+const addDefault = createOrUpdate => (attr, validator) => {
+  if (createOrUpdate === 'creation') {
+    if (
+      ((attr.type === 'component' && attr.repeatable) || attr.type === 'dynamiczone') &&
+      !attr.required
+    ) {
+      validator = validator.default([]);
+    } else {
+      validator = validator.default(attr.default);
+    }
+  } else {
+    validator = validator.default(undefined);
+  }
+
+  return validator;
+};
+
+const preventCast = validator => validator.transform((val, originalVal) => originalVal);
+
+const createComponentValidator = createOrUpdate => (attr, data, { isDraft }) => {
+  let validator;
+
+  const model = strapi.getModel(attr.component);
+  if (!model) {
+    throw new Error('Validation failed: Model not found');
+  }
+
+  if (prop('repeatable', attr) === true) {
+    validator = yup
+      .array()
+      .of(
+        yup.lazy(item => createModelValidator(createOrUpdate)(model, item, { isDraft }).notNull())
+      );
+    validator = addRequiredValidation(createOrUpdate)(true, validator);
+    validator = addMinMax(attr, validator, data);
+  } else {
+    validator = createModelValidator(createOrUpdate)(model, data, { isDraft });
+    validator = addRequiredValidation(createOrUpdate)(!isDraft && attr.required, validator);
+  }
+
+  return validator;
+};
+
+const createDzValidator = createOrUpdate => (attr, data, { isDraft }) => {
+  let validator;
+
+  validator = yup.array().of(
+    yup.lazy(item => {
+      const model = strapi.getModel(prop('__component', item));
+      const schema = yup
+        .object()
+        .shape({
+          __component: yup
+            .string()
+            .required()
+            .oneOf(Object.keys(strapi.components)),
+        })
+        .notNull();
+
+      return model
+        ? schema.concat(createModelValidator(createOrUpdate)(model, item, { isDraft }))
+        : schema;
+    })
+  );
+  validator = addRequiredValidation(createOrUpdate)(true, validator);
+  validator = addMinMax(attr, validator, data);
+
+  return validator;
+};
+
+const createRelationValidator = createOrUpdate => (attr, data, { isDraft }) => {
+  let validator;
+
+  if (Array.isArray(data)) {
+    validator = yup.array().of(yup.mixed());
+  } else {
+    validator = yup.mixed();
+  }
+  validator = addRequiredValidation(createOrUpdate)(!isDraft && attr.required, validator);
+
+  return validator;
+};
+
+const createScalarAttributeValidator = createOrUpdate => (attr, { isDraft }) => {
+  let validator;
+
+  if (has(attr.type, validators)) {
+    validator = validators[attr.type](attr, { isDraft });
+  } else {
+    // No validators specified - fall back to mixed
+    validator = yup.mixed();
+  }
+
+  validator = addRequiredValidation(createOrUpdate)(!isDraft && attr.required, validator);
+
+  return validator;
+};
+
+const createAttributeValidator = createOrUpdate => (attr, data, { isDraft }) => {
+  let validator;
+
+  if (isMediaAttribute(attr)) {
+    validator = yup.mixed();
+  } else if (isScalarAttribute(attr)) {
+    validator = createScalarAttributeValidator(createOrUpdate)(attr, { isDraft });
+  } else {
+    if (attr.type === 'component') {
+      validator = createComponentValidator(createOrUpdate)(attr, data, { isDraft });
+    } else if (attr.type === 'dynamiczone') {
+      validator = createDzValidator(createOrUpdate)(attr, data, { isDraft });
+    } else {
+      validator = createRelationValidator(createOrUpdate)(attr, data, { isDraft });
+    }
+
+    validator = preventCast(validator);
+  }
+
+  validator = addDefault(createOrUpdate)(attr, validator);
+
+  return validator;
+};
+
+const createModelValidator = createOrUpdate => (model, data, { isDraft }) => {
+  const writableAttributes = model ? getWritableAttributes(model) : [];
+
+  const schema = writableAttributes.reduce((validators, attributeName) => {
+    const validator = createAttributeValidator(createOrUpdate)(
+      model.attributes[attributeName],
+      prop(attributeName, data),
+      { isDraft }
+    );
+
+    return assoc(attributeName, validator)(validators);
+  }, {});
+
+  return yup.object().shape(schema);
+};
+
+const createValidateEntity = createOrUpdate => async (model, data, { isDraft = false } = {}) => {
+  try {
+    const validator = createModelValidator(createOrUpdate)(model, data, { isDraft }).required();
+    return await validator.validate(data, { abortEarly: false });
+  } catch (e) {
+    throw strapi.errors.badRequest('ValidationError', { errors: formatYupErrors(e) });
+  }
+};
+
+module.exports = {
+  validateEntityCreation: createValidateEntity('creation'),
+  validateEntityUpdate: createValidateEntity('update'),
+};

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

@@ -0,0 +1,123 @@
+'use strict';
+
+const _ = require('lodash');
+
+const { yup } = require('@strapi/utils');
+
+/**
+ * Utility function to compose validators
+ */
+const composeValidators = (...fns) => (attr, { isDraft }) => {
+  return fns.reduce((validator, fn) => {
+    return fn(attr, validator, { isDraft });
+  }, yup.mixed());
+};
+
+/* Validator utils */
+
+/**
+ * Adds minLength validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMinLengthValidator = ({ minLength }, validator, { isDraft }) =>
+  _.isInteger(minLength) && !isDraft ? validator.min(minLength) : validator;
+
+/**
+ * Adds maxLength validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMaxLengthValidator = ({ maxLength }, validator) =>
+  _.isInteger(maxLength) ? validator.max(maxLength) : validator;
+
+/**
+ * Adds min integer validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMinIntegerValidator = ({ min }, validator) =>
+  _.isNumber(min) ? validator.min(_.toInteger(min)) : validator;
+
+/**
+ * Adds max integer validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMaxIntegerValidator = ({ max }, validator) =>
+  _.isNumber(max) ? validator.max(_.toInteger(max)) : validator;
+
+/**
+ * Adds min float/decimal validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMinFloatValidator = ({ min }, validator) =>
+  _.isNumber(min) ? validator.min(min) : validator;
+
+/**
+ * Adds max float/decimal validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addMaxFloatValidator = ({ max }, validator) =>
+  _.isNumber(max) ? validator.max(max) : validator;
+
+/**
+ * Adds regex validator
+ * @param {Object} attribute model attribute
+ * @param {Object} validator yup validator
+ */
+const addStringRegexValidator = ({ regex }, validator) =>
+  _.isUndefined(regex) ? validator : validator.matches(new RegExp(regex));
+
+/* Type validators */
+
+const stringValidator = composeValidators(
+  () => yup.string().transform((val, originalVal) => originalVal),
+  addMinLengthValidator,
+  addMaxLengthValidator,
+  addStringRegexValidator
+);
+
+const emailValidator = composeValidators(stringValidator, (attr, validator) => validator.email());
+
+const uidValidator = composeValidators(stringValidator, (attr, validator) =>
+  validator.matches(new RegExp('^[A-Za-z0-9-_.~]*$'))
+);
+
+const enumerationValidator = attr => {
+  return yup.string().oneOf((Array.isArray(attr.enum) ? attr.enum : [attr.enum]).concat(null));
+};
+
+const integerValidator = composeValidators(
+  () => yup.number().integer(),
+  addMinIntegerValidator,
+  addMaxIntegerValidator
+);
+
+const floatValidator = composeValidators(
+  () => yup.number(),
+  addMinFloatValidator,
+  addMaxFloatValidator
+);
+
+module.exports = {
+  string: stringValidator,
+  text: stringValidator,
+  richtext: stringValidator,
+  password: stringValidator,
+  email: emailValidator,
+  enumeration: enumerationValidator,
+  boolean: () => yup.boolean(),
+  uid: uidValidator,
+  json: () => yup.mixed(),
+  integer: integerValidator,
+  biginteger: () => yup.mixed(),
+  float: floatValidator,
+  decimal: floatValidator,
+  date: () => yup.mixed(),
+  time: () => yup.mixed(),
+  datetime: () => yup.mixed(),
+  timestamp: () => yup.mixed(),
+};

package/lib/services/event-hub.js

@@ -0,0 +1,15 @@
+/**
+ * The event hub is Strapi's event control center.
+ */
+'use strict';
+
+const EventEmitter = require('events');
+
+class EventHub extends EventEmitter {}
+
+/**
+ * Expose a factory function instead of the class
+ */
+module.exports = function createEventHub(opts) {
+  return new EventHub(opts);
+};

package/lib/services/fs.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const path = require('path');
+const fse = require('fs-extra');
+
+/**
+ * create strapi fs layer
+ */
+module.exports = strapi => {
+  function normalizePath(optPath) {
+    const filePath = Array.isArray(optPath) ? optPath.join('/') : optPath;
+
+    const normalizedPath = path.normalize(filePath).replace(/^\/?(\.\/|\.\.\/)+/, '');
+
+    return path.join(strapi.dirs.root, normalizedPath);
+  }
+
+  const strapiFS = {
+    /**
+     * Writes a file in a strapi app
+     * @param {Array|string} optPath - file path
+     * @param {string} data - content
+     */
+    writeAppFile(optPath, data) {
+      const writePath = normalizePath(optPath);
+      return fse.ensureFile(writePath).then(() => fse.writeFile(writePath, data));
+    },
+
+    /**
+     * Writes a file in a plugin extensions folder
+     * @param {string} plugin - plugin name
+     * @param {Array|string} optPath - path to file
+     * @param {string} data - content
+     */
+    writePluginFile(plugin, optPath, data) {
+      const newPath = ['extensions', plugin].concat(optPath).join('/');
+      return strapiFS.writeAppFile(newPath, data);
+    },
+
+    /**
+     * Removes a file in strapi app
+     */
+    removeAppFile(optPath) {
+      const removePath = normalizePath(optPath);
+      return fse.remove(removePath);
+    },
+
+    /**
+     * Appends a file in strapi app
+     */
+    appendFile(optPath, data) {
+      const writePath = normalizePath(optPath);
+      return fse.appendFileSync(writePath, data);
+    },
+  };
+
+  return strapiFS;
+};

package/lib/services/metrics/index.js

@@ -0,0 +1,104 @@
+'use strict';
+/**
+ * Strapi telemetry package.
+ * You can learn more at https://strapi.io/documentation/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');
+const isTruthy = require('./is-truthy');
+
+const LIMITED_EVENTS = [
+  'didSaveMediaWithAlternativeText',
+  'didSaveMediaWithCaption',
+  'didDisableResponsiveDimensions',
+  'didEnableResponsiveDimensions',
+];
+
+const createTelemetryInstance = strapi => {
+  const uuid = strapi.config.get('uuid');
+  const isDisabled = !uuid || isTruthy(process.env.STRAPI_TELEMETRY_DISABLED);
+
+  const crons = [];
+  const sender = createSender(strapi);
+  const sendEvent = wrapWithRateLimit(sender, { limitedEvents: LIMITED_EVENTS });
+
+  if (!isDisabled) {
+    const pingCron = scheduleJob('0 0 12 * * *', () => sendEvent('ping'));
+    crons.push(pingCron);
+
+    strapi.server.use(createMiddleware({ sendEvent }));
+  }
+
+  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',
+        {
+          licenseInfo: {
+            ...ee.licenseInfo,
+            projectHash: hashProject(strapi),
+            dependencyHash: hashDep(strapi),
+          },
+        },
+        {
+          headers: { 'x-strapi-project': 'enterprise' },
+        }
+      );
+    };
+
+    if (!pingDisabled) {
+      const licenseCron = scheduleJob('0 0 0 * * 7', () => sendLicenseCheck());
+      crons.push(licenseCron);
+
+      sendLicenseCheck();
+    }
+  }
+
+  return {
+    destroy() {
+      // clear open handles
+      crons.forEach(cron => cron.cancel());
+    },
+    async send(event, payload) {
+      if (isDisabled) return true;
+      return sendEvent(event, payload);
+    },
+  };
+};
+
+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.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/is-truthy.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const _ = require('lodash');
+
+const isTruthy = val => {
+  return [1, true].includes(val) || ['true', '1'].includes(_.toLower(val));
+};
+
+module.exports = isTruthy;

package/lib/services/metrics/middleware.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const createMiddleware = ({ sendEvent }) => {
+  const _state = {
+    currentDay: null,
+    counter: 0,
+  };
+
+  return async (ctx, next) => {
+    const { url, method } = ctx.request;
+
+    if (!url.includes('.') && ['GET', 'PUT', 'POST', 'DELETE'].includes(method)) {
+      const dayOfMonth = new Date().getDate();
+
+      if (dayOfMonth !== _state.currentDay) {
+        _state.currentDay = dayOfMonth;
+        _state.counter = 0;
+      }
+
+      // Send max. 1000 events per day.
+      if (_state.counter < 1000) {
+        sendEvent('didReceiveRequest', { url: ctx.request.url });
+
+        // Increase counter.
+        _state.counter++;
+      }
+    }
+
+    await next();
+  };
+};
+
+module.exports = createMiddleware;

package/lib/services/metrics/rate-limiter.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * @param events a list of events that need to be limited
+ */
+module.exports = (sender, { limitedEvents = [] } = {}) => {
+  let currentDay = new Date().getDate();
+  const eventCache = new Map();
+
+  return async (event, ...args) => {
+    if (!limitedEvents.includes(event)) {
+      return sender(event, ...args);
+    }
+
+    if (new Date().getDate() !== currentDay) {
+      eventCache.clear();
+      currentDay = new Date().getDate();
+    }
+
+    if (eventCache.has(event)) {
+      return false;
+    }
+
+    eventCache.set(event, true);
+    return sender(event, ...args);
+  };
+};