@strapi/utils 4.0.0-next.6 → 4.0.0

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.server, forAdminBuild);
+  const { serverUrl, adminUrl } = getConfigUrls(config, forAdminBuild);
   let url = adminOrServer === 'server' ? serverUrl : adminUrl;
 
   if (url.startsWith('http')) {
@@ -68,11 +71,12 @@ const getAbsoluteUrl = adminOrServer => (config, forAdminBuild = false) => {
   }
 
   let hostname =
-    config.environment === 'development' && ['127.0.0.1', '0.0.0.0'].includes(config.server.host)
+    config.get('environment') === 'development' &&
+    ['127.0.0.1', '0.0.0.0'].includes(config.get('server.host'))
       ? 'localhost'
-      : config.server.host;
+      : config.get('server.host');
 
-  return `http://${hostname}:${config.server.port}${url}`;
+  return `http://${hostname}:${config.get('server.port')}${url}`;
 };
 
 module.exports = {

package/lib/content-types.js

@@ -1,18 +1,18 @@
 'use strict';
 
 const _ = require('lodash');
-const pluralize = require('pluralize');
+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';
@@ -32,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 = {}) => {
@@ -43,7 +53,7 @@ const getNonWritableAttributes = (model = {}) => {
     []
   );
 
-  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(), ...nonWritableAttributes]);
+  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonWritableAttributes]);
 };
 
 const getWritableAttributes = (model = {}) => {
@@ -61,7 +71,7 @@ const getNonVisibleAttributes = model => {
     []
   );
 
-  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(), ...nonVisibleAttributes]);
+  return _.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonVisibleAttributes]);
 };
 
 const getVisibleAttributes = model => {
@@ -101,108 +111,6 @@ const isMediaAttribute = attr => {
   return attr.type === 'media';
 };
 
-const getKind = obj => obj.kind || 'collectionType';
-
-const pickSchema = model => {
-  const schema = _.cloneDeep(
-    _.pick(model, ['collectionName', 'info', 'options', 'pluginOptions', 'attributes'])
-  );
-
-  schema.kind = getKind(model);
-  return schema;
-};
-
-const createContentType = (model, { modelName }, { apiName, pluginName } = {}) => {
-  if (apiName) {
-    Object.assign(model, {
-      uid: `application::${apiName}.${modelName}`,
-      apiName,
-      collectionName: model.collectionName || modelName.toLocaleLowerCase(),
-      globalId: getGlobalId(model, modelName),
-    });
-  } else if (pluginName) {
-    Object.assign(model, {
-      uid: `plugins::${pluginName}.${modelName}`,
-      plugin: pluginName,
-      collectionName: model.collectionName || `${pluginName}_${modelName}`.toLowerCase(),
-      globalId: getGlobalId(model, modelName, pluginName),
-    });
-  } else {
-    Object.assign(model, {
-      uid: `strapi::${modelName}`,
-      plugin: 'admin',
-      globalId: getGlobalId(model, modelName, 'admin'),
-    });
-  }
-
-  Object.assign(model, {
-    __schema__: pickSchema(model),
-    kind: getKind(model),
-    modelType: 'contentType',
-    modelName,
-  });
-
-  Object.defineProperty(model, 'privateAttributes', {
-    get() {
-      // FIXME: to fix
-      // return strapi.getModel(model.uid).privateAttributes;
-      return [];
-    },
-    configurable: true,
-  });
-
-  Object.assign(model.attributes, {
-    [CREATED_AT_ATTRIBUTE]: {
-      type: 'datetime',
-      default: () => new Date(),
-    },
-    // TODO: handle on edit set to new date
-    [UPDATED_AT_ATTRIBUTE]: {
-      type: 'datetime',
-      default: () => new Date(),
-    },
-  });
-
-  if (hasDraftAndPublish(model)) {
-    model.attributes[PUBLISHED_AT_ATTRIBUTE] = {
-      type: 'datetime',
-      configurable: false,
-      writable: true,
-      visible: false,
-    };
-  }
-
-  const isPrivate = !_.get(model, 'options.populateCreatorFields', false);
-
-  model.attributes[CREATED_BY_ATTRIBUTE] = {
-    type: 'relation',
-    relation: 'oneToOne',
-    target: 'strapi::user',
-    configurable: false,
-    writable: false,
-    visible: false,
-    useJoinTable: false,
-    private: isPrivate,
-  };
-
-  model.attributes[UPDATED_BY_ATTRIBUTE] = {
-    type: 'relation',
-    relation: 'oneToOne',
-    target: 'strapi::user',
-    configurable: false,
-    writable: false,
-    visible: false,
-    useJoinTable: false,
-    private: isPrivate,
-  };
-};
-
-const getGlobalId = (model, modelName, prefix) => {
-  let globalId = prefix ? `${prefix}-${modelName}` : modelName;
-
-  return model.globalId || _.upperFirst(_.camelCase(globalId));
-};
-
 const isRelationalAttribute = attribute => attribute.type === 'relation';
 const isComponentAttribute = attribute => ['component', 'dynamiczone'].includes(attribute.type);
 
@@ -222,8 +130,8 @@ const isTypedAttribute = (attribute, type) => {
  */
 const getContentTypeRoutePrefix = contentType => {
   return isSingleType(contentType)
-    ? _.kebabCase(contentType.modelName)
-    : _.kebabCase(pluralize(contentType.modelName));
+    ? _.kebabCase(contentType.info.singularName)
+    : _.kebabCase(contentType.info.pluralName);
 };
 
 module.exports = {
@@ -240,13 +148,12 @@ module.exports = {
   isWritableAttribute,
   getNonVisibleAttributes,
   getVisibleAttributes,
+  getTimestamps,
   isVisibleAttribute,
   hasDraftAndPublish,
   isDraft,
   isSingleType,
   isCollectionType,
   isKind,
-  createContentType,
-  getGlobalId,
   getContentTypeRoutePrefix,
 };

package/lib/convert-query-params.js

@@ -0,0 +1,252 @@
+'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}`);
+  }
+
+  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,
@@ -23,6 +17,8 @@ const {
   escapeQuery,
   stringIncludes,
   stringEquals,
+  isKebabCase,
+  isCamelCase,
 } = require('./string-formatting');
 const { removeUndefined } = require('./object-formatting');
 const { getConfigUrls, getAbsoluteAdminUrl, getAbsoluteServerUrl } = require('./config');
@@ -34,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,
@@ -60,6 +57,8 @@ module.exports = {
   generateTimestampCode,
   stringIncludes,
   stringEquals,
+  isKebabCase,
+  isCamelCase,
   contentTypes,
   webhook,
   env,
@@ -67,4 +66,9 @@ module.exports = {
   setCreatorFields,
   hooks,
   providerFactory,
+  pagination,
+  pipeAsync,
+  errors,
+  validateYupSchema,
+  validateYupSchemaSync,
 };