@strapi/utils 4.0.0-next.7 → 4.0.1

package/lib/build-query.js

@@ -60,7 +60,7 @@ const getAssociationFromFieldKey = ({ model, field }) => {
 const castInput = ({ type, value, operator }) => {
   return Array.isArray(value)
     ? value.map(val => castValue({ type, operator, value: val }))
-    : castValue({ type, operator, value: value });
+    : castValue({ type, operator, value });
 };
 
 /**

package/lib/config.js

@@ -3,7 +3,10 @@
 const _ = require('lodash');
 const { getCommonPath } = require('./string-formatting');
 
-const getConfigUrls = (serverConfig, forAdminBuild = false) => {
+const getConfigUrls = (config, forAdminBuild = false) => {
+  const serverConfig = config.get('server');
+  const adminConfig = config.get('admin');
+
   // Defines serverUrl value
   let serverUrl = _.get(serverConfig, 'url', '');
   serverUrl = _.trim(serverUrl, '/ ');
@@ -23,7 +26,7 @@ const getConfigUrls = (serverConfig, forAdminBuild = false) => {
   }
 
   // Defines adminUrl value
-  let adminUrl = _.get(serverConfig, 'admin.url', '/admin');
+  let adminUrl = _.get(adminConfig, 'url', '/admin');
   adminUrl = _.trim(adminUrl, '/ ');
   if (typeof adminUrl !== 'string') {
     throw new Error('Invalid admin url config. Make sure the url is a non-empty string.');
@@ -60,7 +63,7 @@ const getConfigUrls = (serverConfig, forAdminBuild = false) => {
 };
 
 const getAbsoluteUrl = adminOrServer => (config, forAdminBuild = false) => {
-  const { serverUrl, adminUrl } = getConfigUrls(config.get('server'), forAdminBuild);
+  const { serverUrl, adminUrl } = getConfigUrls(config, forAdminBuild);
   let url = adminOrServer === 'server' ? serverUrl : adminUrl;
 
   if (url.startsWith('http')) {

package/lib/content-types.js

@@ -1,17 +1,18 @@
 'use strict';
 
 const _ = require('lodash');
+const { has } = require('lodash/fp');
 
 const SINGLE_TYPE = 'singleType';
 const COLLECTION_TYPE = 'collectionType';
 
 const ID_ATTRIBUTE = 'id';
-const PUBLISHED_AT_ATTRIBUTE = 'published_at';
-const CREATED_BY_ATTRIBUTE = 'created_by';
-const UPDATED_BY_ATTRIBUTE = 'updated_by';
+const PUBLISHED_AT_ATTRIBUTE = 'publishedAt';
+const CREATED_BY_ATTRIBUTE = 'createdBy';
+const UPDATED_BY_ATTRIBUTE = 'updatedBy';
 
-const CREATED_AT_ATTRIBUTE = 'created_at';
-const UPDATED_AT_ATTRIBUTE = 'updated_at';
+const CREATED_AT_ATTRIBUTE = 'createdAt';
+const UPDATED_AT_ATTRIBUTE = 'updatedAt';
 
 const DP_PUB_STATE_LIVE = 'live';
 const DP_PUB_STATE_PREVIEW = 'preview';
@@ -31,8 +32,18 @@ const constants = {
   COLLECTION_TYPE,
 };
 
-const getTimestamps = () => {
-  return [CREATED_AT_ATTRIBUTE, UPDATED_AT_ATTRIBUTE];
+const getTimestamps = model => {
+  const attributes = [];
+
+  if (has(CREATED_AT_ATTRIBUTE, model.attributes)) {
+    attributes.push(CREATED_AT_ATTRIBUTE);
+  }
+
+  if (has(UPDATED_AT_ATTRIBUTE, model.attributes)) {
+    attributes.push(UPDATED_AT_ATTRIBUTE);
+  }
+
+  return attributes;
 };
 
 const getNonWritableAttributes = (model = {}) => {
@@ -42,7 +53,7 @@ const getNonWritableAttributes = (model = {}) => {
     []
   );
 
-  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(), ...nonWritableAttributes]);
+  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonWritableAttributes]);
 };
 
 const getWritableAttributes = (model = {}) => {
@@ -60,7 +71,7 @@ const getNonVisibleAttributes = model => {
     []
   );
 
-  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(), ...nonVisibleAttributes]);
+  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonVisibleAttributes]);
 };
 
 const getVisibleAttributes = model => {
@@ -137,6 +148,7 @@ module.exports = {
   isWritableAttribute,
   getNonVisibleAttributes,
   getVisibleAttributes,
+  getTimestamps,
   isVisibleAttribute,
   hasDraftAndPublish,
   isDraft,

package/lib/convert-query-params.js

@@ -0,0 +1,254 @@
+'use strict';
+
+/**
+ * Converts the standard Strapi REST query params to a more usable format for querying
+ * You can read more here: https://docs.strapi.io/developer-docs/latest/developer-resources/database-apis-reference/rest-api.html#filters
+ */
+const { has } = require('lodash/fp');
+const _ = require('lodash');
+const parseType = require('./parse-type');
+const contentTypesUtils = require('./content-types');
+
+const { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;
+
+class InvalidOrderError extends Error {
+  constructor() {
+    super();
+    this.message = 'Invalid order. order can only be one of asc|desc|ASC|DESC';
+  }
+}
+class InvalidSortError extends Error {
+  constructor() {
+    super();
+    this.message =
+      'Invalid sort parameter. Expected a string, an array of strings, a sort object or an array of sort objects';
+  }
+}
+
+const validateOrder = order => {
+  if (!['asc', 'desc'].includes(order.toLocaleLowerCase())) {
+    throw new InvalidOrderError();
+  }
+};
+
+const convertCountQueryParams = countQuery => {
+  return parseType({ type: 'boolean', value: countQuery });
+};
+
+/**
+ * Sort query parser
+ * @param {string} sortQuery - ex: id:asc,price:desc
+ */
+const convertSortQueryParams = sortQuery => {
+  if (typeof sortQuery === 'string') {
+    return sortQuery.split(',').map(value => convertSingleSortQueryParam(value));
+  }
+
+  if (Array.isArray(sortQuery)) {
+    return sortQuery.flatMap(sortValue => convertSortQueryParams(sortValue));
+  }
+
+  if (_.isPlainObject(sortQuery)) {
+    return convertNestedSortQueryParam(sortQuery);
+  }
+
+  throw new InvalidSortError();
+};
+
+const convertSingleSortQueryParam = sortQuery => {
+  // split field and order param with default order to ascending
+  const [field, order = 'asc'] = sortQuery.split(':');
+
+  if (field.length === 0) {
+    throw new Error('Field cannot be empty');
+  }
+
+  validateOrder(order);
+
+  return _.set({}, field, order);
+};
+
+const convertNestedSortQueryParam = sortQuery => {
+  const transformedSort = {};
+  for (const field in sortQuery) {
+    const order = sortQuery[field];
+
+    // this is a deep sort
+    if (_.isPlainObject(order)) {
+      transformedSort[field] = convertNestedSortQueryParam(order);
+    } else {
+      validateOrder(order);
+      transformedSort[field] = order;
+    }
+  }
+
+  return transformedSort;
+};
+
+/**
+ * Start query parser
+ * @param {string} startQuery
+ */
+const convertStartQueryParams = startQuery => {
+  const startAsANumber = _.toNumber(startQuery);
+
+  if (!_.isInteger(startAsANumber) || startAsANumber < 0) {
+    throw new Error(`convertStartQueryParams expected a positive integer got ${startAsANumber}`);
+  }
+
+  return startAsANumber;
+};
+
+/**
+ * Limit query parser
+ * @param {string} limitQuery
+ */
+const convertLimitQueryParams = limitQuery => {
+  const limitAsANumber = _.toNumber(limitQuery);
+
+  if (!_.isInteger(limitAsANumber) || (limitAsANumber !== -1 && limitAsANumber < 0)) {
+    throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
+  }
+
+  if (limitAsANumber === -1) return null;
+
+  return limitAsANumber;
+};
+
+class InvalidPopulateError extends Error {
+  constructor() {
+    super();
+    this.message =
+      'Invalid populate parameter. Expected a string, an array of strings, a populate object';
+  }
+}
+
+// NOTE: we could support foo.* or foo.bar.* etc later on
+const convertPopulateQueryParams = (populate, depth = 0) => {
+  if (depth === 0 && populate === '*') {
+    return true;
+  }
+
+  if (typeof populate === 'string') {
+    return populate.split(',').map(value => _.trim(value));
+  }
+
+  if (Array.isArray(populate)) {
+    // map convert
+    return _.uniq(
+      populate.flatMap(value => {
+        if (typeof value !== 'string') {
+          throw new InvalidPopulateError();
+        }
+
+        return value.split(',').map(value => _.trim(value));
+      })
+    );
+  }
+
+  if (_.isPlainObject(populate)) {
+    const transformedPopulate = {};
+    for (const key in populate) {
+      transformedPopulate[key] = convertNestedPopulate(populate[key]);
+    }
+
+    return transformedPopulate;
+  }
+
+  throw new InvalidPopulateError();
+};
+
+const convertNestedPopulate = subPopulate => {
+  if (subPopulate === '*') {
+    return true;
+  }
+
+  if (_.isBoolean(subPopulate)) {
+    return subPopulate;
+  }
+
+  if (!_.isPlainObject(subPopulate)) {
+    throw new Error(`Invalid nested populate. Expected '*' or an object`);
+  }
+
+  // TODO: We will need to consider a way to add limitation / pagination
+  const { sort, filters, fields, populate, count } = subPopulate;
+
+  const query = {};
+
+  if (sort) {
+    query.orderBy = convertSortQueryParams(sort);
+  }
+
+  if (filters) {
+    query.where = convertFiltersQueryParams(filters);
+  }
+
+  if (fields) {
+    query.select = convertFieldsQueryParams(fields);
+  }
+
+  if (populate) {
+    query.populate = convertPopulateQueryParams(populate);
+  }
+
+  if (count) {
+    query.count = convertCountQueryParams(count);
+  }
+
+  return query;
+};
+
+const convertFieldsQueryParams = (fields, depth = 0) => {
+  if (depth === 0 && fields === '*') {
+    return undefined;
+  }
+
+  if (typeof fields === 'string') {
+    const fieldsValues = fields.split(',').map(value => _.trim(value));
+    return _.uniq(['id', ...fieldsValues]);
+  }
+
+  if (Array.isArray(fields)) {
+    // map convert
+    const fieldsValues = fields.flatMap(value => convertFieldsQueryParams(value, depth + 1));
+    return _.uniq(['id', ...fieldsValues]);
+  }
+
+  throw new Error('Invalid fields parameter. Expected a string or an array of strings');
+};
+
+const convertFiltersQueryParams = filters => filters;
+
+const convertPublicationStateParams = (type, params = {}, query = {}) => {
+  if (!type) {
+    return;
+  }
+
+  const { publicationState } = params;
+
+  if (!_.isNil(publicationState)) {
+    if (!contentTypesUtils.constants.DP_PUB_STATES.includes(publicationState)) {
+      throw new Error(
+        `Invalid publicationState. Expected one of 'preview','live' received: ${publicationState}.`
+      );
+    }
+
+    // NOTE: this is the query layer filters not the entity service filters
+    query.filters = ({ meta }) => {
+      if (publicationState === 'live' && has(PUBLISHED_AT_ATTRIBUTE, meta.attributes)) {
+        return { [PUBLISHED_AT_ATTRIBUTE]: { $notNull: true } };
+      }
+    };
+  }
+};
+
+module.exports = {
+  convertSortQueryParams,
+  convertStartQueryParams,
+  convertLimitQueryParams,
+  convertPopulateQueryParams,
+  convertFiltersQueryParams,
+  convertFieldsQueryParams,
+  convertPublicationStateParams,
+};

package/lib/errors.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { HttpError } = require('http-errors');
+const { formatYupErrors } = require('./format-yup-error');
+
+/* ApplicationError */
+class ApplicationError extends Error {
+  constructor(message, details = {}) {
+    super();
+    this.name = 'ApplicationError';
+    this.message = message || 'An application error occured';
+    this.details = details;
+  }
+}
+
+class ValidationError extends ApplicationError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = 'ValidationError';
+  }
+}
+
+class YupValidationError extends ValidationError {
+  constructor(yupError, message) {
+    super();
+    const { errors, message: yupMessage } = formatYupErrors(yupError);
+    this.message = message || yupMessage;
+    this.details = { errors };
+  }
+}
+
+class PaginationError extends ApplicationError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = 'PaginationError';
+    this.message = message || 'Invalid pagination';
+  }
+}
+
+class NotFoundError extends ApplicationError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = 'NotFoundError';
+    this.message = message || 'Entity not found';
+  }
+}
+
+class ForbiddenError extends ApplicationError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = 'ForbiddenError';
+    this.message = message || 'Forbidden access';
+  }
+}
+
+class PayloadTooLargeError extends ApplicationError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = 'PayloadTooLargeError';
+    this.message = message || 'Entity too large';
+  }
+}
+
+class UnauthorizedError extends ApplicationError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = 'UnauthorizedError';
+    this.message = message || 'Unauthorized';
+  }
+}
+
+module.exports = {
+  HttpError,
+  ApplicationError,
+  ValidationError,
+  YupValidationError,
+  PaginationError,
+  NotFoundError,
+  ForbiddenError,
+  PayloadTooLargeError,
+  UnauthorizedError,
+};

package/lib/format-yup-error.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { isEmpty, toPath } = require('lodash/fp');
+
+const formatYupInnerError = yupError => ({
+  path: toPath(yupError.path),
+  message: yupError.message,
+  name: yupError.name,
+});
+
+const formatYupErrors = yupError => ({
+  errors: isEmpty(yupError.inner)
+    ? [formatYupInnerError(yupError)]
+    : yupError.inner.map(formatYupInnerError),
+  message: yupError.message,
+});
+
+module.exports = {
+  formatYupErrors,
+};

package/lib/hooks.js

@@ -24,12 +24,14 @@ const createHook = () => {
       return state.handlers;
     },
 
-    register: handler => {
+    register(handler) {
       state.handlers.push(handler);
+      return this;
     },
 
-    delete: handler => {
+    delete(handler) {
       state.handlers = remove(eq(handler), state.handlers);
+      return this;
     },
 
     call() {
@@ -80,7 +82,7 @@ const createAsyncSeriesWaterfallHook = () => ({
 const createAsyncParallelHook = () => ({
   ...createHook(),
 
-  call(context) {
+  async call(context) {
     const promises = this.handlers.map(handler => handler(cloneDeep(context)));
 
     return Promise.all(promises);

package/lib/index.js

@@ -4,18 +4,12 @@
  * Export shared utilities
  */
 const { buildQuery, hasDeepFilters } = require('./build-query');
-const {
-  convertRestQueryParams,
-  VALID_REST_OPERATORS,
-  QUERY_OPERATORS,
-} = require('./convert-rest-query-params');
 const parseMultipartData = require('./parse-multipart');
-const sanitizeEntity = require('./sanitize-entity');
 const parseType = require('./parse-type');
-const finder = require('./finder');
 const policy = require('./policy');
 const templateConfiguration = require('./template-configuration');
-const { yup, formatYupErrors } = require('./validators');
+const { yup, handleYupError, validateYupSchema, validateYupSchemaSync } = require('./validators');
+const errors = require('./errors');
 const {
   nameToSlug,
   nameToCollectionName,
@@ -36,20 +30,21 @@ const relations = require('./relations');
 const setCreatorFields = require('./set-creator-fields');
 const hooks = require('./hooks');
 const providerFactory = require('./provider-factory');
+const pagination = require('./pagination');
+const sanitize = require('./sanitize');
+const traverseEntity = require('./traverse-entity');
+const pipeAsync = require('./pipe-async');
 
 module.exports = {
   yup,
-  formatYupErrors,
-  finder,
+  handleYupError,
   policy,
   templateConfiguration,
-  convertRestQueryParams,
-  VALID_REST_OPERATORS,
-  QUERY_OPERATORS,
   buildQuery,
   hasDeepFilters,
   parseMultipartData,
-  sanitizeEntity,
+  sanitize,
+  traverseEntity,
   parseType,
   nameToSlug,
   nameToCollectionName,
@@ -71,4 +66,9 @@ module.exports = {
   setCreatorFields,
   hooks,
   providerFactory,
+  pagination,
+  pipeAsync,
+  errors,
+  validateYupSchema,
+  validateYupSchemaSync,
 };

package/lib/pagination.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const { merge, pipe, omit, isNil } = require('lodash/fp');
+const { PaginationError } = require('./errors');
+
+const STRAPI_DEFAULTS = {
+  offset: {
+    start: 0,
+    limit: 10,
+  },
+  page: {
+    page: 1,
+    pageSize: 10,
+  },
+};
+
+const paginationAttributes = ['start', 'limit', 'page', 'pageSize'];
+
+const withMaxLimit = (limit, maxLimit = -1) => {
+  if (maxLimit === -1 || limit < maxLimit) {
+    return limit;
+  }
+
+  return maxLimit;
+};
+
+// Ensure minimum page & pageSize values (page >= 1, pageSize >= 0, start >= 0, limit >= 0)
+const ensureMinValues = ({ start, limit }) => ({
+  start: Math.max(start, 0),
+  limit: limit === -1 ? limit : Math.max(limit, 1),
+});
+
+const ensureMaxValues = (maxLimit = -1) => ({ start, limit }) => ({
+  start,
+  limit: withMaxLimit(limit, maxLimit),
+});
+
+// Apply maxLimit as the limit when limit is -1
+const withNoLimit = (pagination, maxLimit = -1) => ({
+  ...pagination,
+  limit: pagination.limit === -1 ? maxLimit : pagination.limit,
+});
+
+const withDefaultPagination = (args, { defaults = {}, maxLimit = -1 } = {}) => {
+  const defaultValues = merge(STRAPI_DEFAULTS, defaults);
+
+  const usePagePagination = !isNil(args.page) || !isNil(args.pageSize);
+  const useOffsetPagination = !isNil(args.start) || !isNil(args.limit);
+
+  const ensureValidValues = pipe(
+    ensureMinValues,
+    ensureMaxValues(maxLimit)
+  );
+
+  // If there is no pagination attribute, don't modify the payload
+  if (!usePagePagination && !useOffsetPagination) {
+    return merge(args, ensureValidValues(defaultValues.offset));
+  }
+
+  // If there is page & offset pagination attributes, throw an error
+  if (usePagePagination && useOffsetPagination) {
+    throw new PaginationError('Cannot use both page & offset pagination in the same query');
+  }
+
+  const pagination = {};
+
+  // Start / Limit
+  if (useOffsetPagination) {
+    const { start, limit } = merge(defaultValues.offset, args);
+
+    Object.assign(pagination, { start, limit });
+  }
+
+  // Page / PageSize
+  if (usePagePagination) {
+    const { page, pageSize } = merge(defaultValues.page, {
+      ...args,
+      pageSize: Math.max(1, args.pageSize),
+    });
+
+    Object.assign(pagination, {
+      start: (page - 1) * pageSize,
+      limit: pageSize,
+    });
+  }
+
+  // Handle -1 limit
+  Object.assign(pagination, withNoLimit(pagination, maxLimit));
+
+  const replacePaginationAttributes = pipe(
+    // Remove pagination attributes
+    omit(paginationAttributes),
+    // Merge the object with the new pagination + ensure minimum & maximum values
+    merge(ensureValidValues(pagination))
+  );
+
+  return replacePaginationAttributes(args);
+};
+
+module.exports = { withDefaultPagination };

package/lib/parse-multipart.js

@@ -3,10 +3,14 @@
 const _ = require('lodash');
 
 module.exports = ctx => {
+  if (!ctx.is('multipart')) {
+    return { data: ctx.request.body, files: {} };
+  }
+
   const { body = {}, files = {} } = ctx.request;
 
   if (!body.data) {
-    throw strapi.errors.badRequest(
+    return ctx.badRequest(
       `When using multipart/form-data you need to provide your data in a JSON 'data' field.`
     );
   }
@@ -15,14 +19,14 @@ module.exports = ctx => {
   try {
     data = JSON.parse(body.data);
   } catch (error) {
-    throw strapi.errors.badRequest(`Invalid 'data' field. 'data' should be a valid JSON.`);
+    return ctx.badRequest(`Invalid 'data' field. 'data' should be a valid JSON.`);
   }
 
   const filesToUpload = Object.keys(files).reduce((acc, key) => {
     const fullPath = _.toPath(key);
 
     if (fullPath.length <= 1 || fullPath[0] !== 'files') {
-      throw strapi.errors.badRequest(
+      return ctx.badRequest(
         `When using multipart/form-data you need to provide your files by prefixing them with the 'files'.
 For example, when a media file is named "avatar", make sure the form key name is "files.avatar"`
       );

package/lib/pipe-async.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = (...methods) => async data => {
+  let res = data;
+
+  for (const method of methods) {
+    res = await method(res);
+  }
+
+  return res;
+};