@strapi/utils 4.0.0-next.9 → 4.0.3

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

@@ -2,12 +2,14 @@
 
 /**
  * Converts the standard Strapi REST query params to a more usable format for querying
- * You can read more here: https://strapi.io/documentation/developer-docs/latest/developer-resources/content-api/content-api.html#filters
+ * 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 QUERY_OPERATORS = ['_where', '_or', '_and'];
+const { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;
 
 class InvalidOrderError extends Error {
   constructor() {
@@ -29,6 +31,10 @@ const validateOrder = order => {
   }
 };
 
+const convertCountQueryParams = countQuery => {
+  return parseType({ type: 'boolean', value: countQuery });
+};
+
 /**
  * Sort query parser
  * @param {string} sortQuery - ex: id:asc,price:desc
@@ -104,6 +110,8 @@ const convertLimitQueryParams = limitQuery => {
     throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
   }
 
+  if (limitAsANumber === -1) return null;
+
   return limitAsANumber;
 };
 
@@ -127,13 +135,15 @@ const convertPopulateQueryParams = (populate, depth = 0) => {
 
   if (Array.isArray(populate)) {
     // map convert
-    return populate.flatMap(value => {
-      if (typeof value !== 'string') {
-        throw new InvalidPopulateError();
-      }
+    return _.uniq(
+      populate.flatMap(value => {
+        if (typeof value !== 'string') {
+          throw new InvalidPopulateError();
+        }
 
-      return value.split(',').map(value => _.trim(value));
-    });
+        return value.split(',').map(value => _.trim(value));
+      })
+    );
   }
 
   if (_.isPlainObject(populate)) {
@@ -141,6 +151,7 @@ const convertPopulateQueryParams = (populate, depth = 0) => {
     for (const key in populate) {
       transformedPopulate[key] = convertNestedPopulate(populate[key]);
     }
+
     return transformedPopulate;
   }
 
@@ -161,7 +172,7 @@ const convertNestedPopulate = subPopulate => {
   }
 
   // TODO: We will need to consider a way to add limitation / pagination
-  const { sort, filters, fields, populate } = subPopulate;
+  const { sort, filters, fields, populate, count } = subPopulate;
 
   const query = {};
 
@@ -181,6 +192,10 @@ const convertNestedPopulate = subPopulate => {
     query.populate = convertPopulateQueryParams(populate);
   }
 
+  if (count) {
+    query.count = convertCountQueryParams(count);
+  }
+
   return query;
 };
 
@@ -203,25 +218,30 @@ const convertFieldsQueryParams = (fields, depth = 0) => {
   throw new Error('Invalid fields parameter. Expected a string or an array of strings');
 };
 
-// NOTE: We could validate the parameters are on existing / non private attributes
 const convertFiltersQueryParams = filters => filters;
 
-// TODO: migrate
-const VALID_REST_OPERATORS = [
-  'eq',
-  'ne',
-  'in',
-  'nin',
-  'contains',
-  'ncontains',
-  'containss',
-  'ncontainss',
-  'lt',
-  'lte',
-  'gt',
-  'gte',
-  'null',
-];
+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,
@@ -230,6 +250,5 @@ module.exports = {
   convertPopulateQueryParams,
   convertFiltersQueryParams,
   convertFieldsQueryParams,
-  VALID_REST_OPERATORS,
-  QUERY_OPERATORS,
+  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,13 +4,12 @@
  * Export shared utilities
  */
 const { buildQuery, hasDeepFilters } = require('./build-query');
-const { VALID_REST_OPERATORS, QUERY_OPERATORS } = require('./convert-query-params');
 const parseMultipartData = require('./parse-multipart');
-const sanitizeEntity = require('./sanitize-entity');
 const parseType = require('./parse-type');
 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,
@@ -31,18 +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,
+  handleYupError,
   policy,
   templateConfiguration,
-  VALID_REST_OPERATORS,
-  QUERY_OPERATORS,
   buildQuery,
   hasDeepFilters,
   parseMultipartData,
-  sanitizeEntity,
+  sanitize,
+  traverseEntity,
   parseType,
   nameToSlug,
   nameToCollectionName,
@@ -64,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

@@ -10,7 +10,7 @@ module.exports = ctx => {
   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.`
     );
   }
@@ -19,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;
+};