@strapi/strapi 4.0.0-next.8 → 4.0.2

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

@@ -1,12 +1,18 @@
 'use strict';
 
+const _ = require('lodash');
 const delegate = require('delegates');
 const {
-  sanitizeEntity,
+  InvalidTimeError,
+  InvalidDateError,
+  InvalidDateTimeError,
+} = require('@strapi/database').errors;
+const {
   webhook: webhookUtils,
   contentTypes: contentTypesUtils,
-  relations: relationsUtils,
+  sanitize,
 } = require('@strapi/utils');
+const { ValidationError } = require('@strapi/utils').errors;
 const uploadFiles = require('../utils/upload-files');
 
 const {
@@ -16,12 +22,21 @@ const {
   deleteComponents,
 } = require('./components');
 const { transformParamsToQuery, pickSelectionParams } = require('./params');
-
-const { MANY_RELATIONS } = relationsUtils.constants;
+const { applyTransforms } = require('./attributes');
 
 // 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 creationPipeline = (data, context) => {
+  return applyTransforms(data, context);
+};
+
+const updatePipeline = (data, context) => {
+  return applyTransforms(data, context);
+};
+
 module.exports = ctx => {
   const implementation = createDefaultImplementation(ctx);
 
@@ -42,32 +57,57 @@ module.exports = ctx => {
   // delegate every method in implementation
   Object.keys(service.implementation).forEach(key => delegator.method(key));
 
+  // wrap methods to handle Database Errors
+  service.decorate(oldService => {
+    const newService = _.mapValues(
+      oldService,
+      (method, methodName) =>
+        async function(...args) {
+          try {
+            return await oldService[methodName].call(this, ...args);
+          } catch (error) {
+            if (
+              databaseErrorsToTransform.some(errorToTransform => error instanceof errorToTransform)
+            ) {
+              throw new ValidationError(error.message);
+            }
+            throw error;
+          }
+        }
+    );
+
+    return newService;
+  });
+
   return service;
 };
 
+/**
+ * @type {import('.').default}
+ */
 const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator }) => ({
   uploadFiles,
 
-  async wrapOptions(options = {}) {
+  async wrapParams(options = {}) {
     return options;
   },
 
-  emitEvent(uid, event, entity) {
+  async emitEvent(uid, event, entity) {
     const model = strapi.getModel(uid);
+    const sanitizedEntity = await sanitize.sanitizers.defaultSanitizeOutput(model, entity);
 
     eventHub.emit(event, {
       model: model.modelName,
-      entry: sanitizeEntity(entity, { model }),
+      entry: sanitizedEntity,
     });
   },
 
-  // TODO: rename to findMany
-  async find(uid, opts) {
+  async findMany(uid, opts) {
     const { kind } = strapi.getModel(uid);
 
-    const { params } = await this.wrapOptions(opts, { uid, action: 'find' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findMany' });
 
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
     if (kind === 'singleType') {
       return db.query(uid).findOne(query);
@@ -77,42 +117,20 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
   },
 
   async findPage(uid, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'findPage' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findPage' });
 
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
     return db.query(uid).findPage(query);
   },
 
   // TODO: streamline the logic based on the populate option
   async findWithRelationCounts(uid, opts) {
-    const model = strapi.getModel(uid);
-
-    const { params } = await this.wrapOptions(opts, { uid, action: 'findWithRelationCounts' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findWithRelationCounts' });
 
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
-    const { attributes } = model;
-
-    const populate = (query.populate || []).reduce((populate, attributeName) => {
-      const attribute = attributes[attributeName];
-
-      if (
-        MANY_RELATIONS.includes(attribute.relation) &&
-        contentTypesUtils.isVisibleAttribute(model, attributeName)
-      ) {
-        populate[attributeName] = { count: true };
-      } else {
-        populate[attributeName] = true;
-      }
-
-      return populate;
-    }, {});
-
-    const { results, pagination } = await db.query(uid).findPage({
-      ...query,
-      populate,
-    });
+    const { results, pagination } = await db.query(uid).findPage(query);
 
     return {
       results,
@@ -121,23 +139,24 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
   },
 
   async findOne(uid, entityId, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'findOne' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findOne' });
 
-    const query = transformParamsToQuery(uid, pickSelectionParams(params));
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
     return db.query(uid).findOne({ ...query, where: { id: entityId } });
   },
 
   async count(uid, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'count' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'count' });
 
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
     return db.query(uid).count(query);
   },
 
   async create(uid, opts) {
-    const { params, data, files } = await this.wrapOptions(opts, { uid, action: 'create' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'create' });
+    const { data, files } = wrappedParams;
 
     const model = strapi.getModel(uid);
 
@@ -145,30 +164,33 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     const validData = await entityValidator.validateEntityCreation(model, data, { isDraft });
 
     // select / populate
-    const query = transformParamsToQuery(uid, pickSelectionParams(params));
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
     // TODO: wrap into transaction
     const componentData = await createComponents(uid, validData);
 
     let entity = await db.query(uid).create({
       ...query,
-      data: Object.assign(omitComponentData(model, validData), componentData),
+      data: creationPipeline(Object.assign(omitComponentData(model, validData), componentData), {
+        contentType: model,
+      }),
     });
 
     // TODO: upload the files then set the links in the entity like with compo to avoid making too many queries
     // FIXME: upload in components
     if (files && Object.keys(files).length > 0) {
       await this.uploadFiles(uid, entity, files);
-      entity = await this.findOne(uid, entity.id, { params });
+      entity = await this.findOne(uid, entity.id, wrappedParams);
     }
 
-    this.emitEvent(uid, ENTRY_CREATE, entity);
+    await this.emitEvent(uid, ENTRY_CREATE, entity);
 
     return entity;
   },
 
   async update(uid, entityId, opts) {
-    const { params, data, files } = await this.wrapOptions(opts, { uid, action: 'update' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'update' });
+    const { data, files } = wrappedParams;
 
     const model = strapi.getModel(uid);
 
@@ -180,11 +202,16 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     const isDraft = contentTypesUtils.isDraft(entityToUpdate, model);
 
-    const validData = await entityValidator.validateEntityUpdate(model, data, {
-      isDraft,
-    });
+    const validData = await entityValidator.validateEntityUpdate(
+      model,
+      data,
+      {
+        isDraft,
+      },
+      entityToUpdate
+    );
 
-    const query = transformParamsToQuery(uid, pickSelectionParams(params));
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
     // TODO: wrap in transaction
     const componentData = await updateComponents(uid, entityToUpdate, validData);
@@ -192,26 +219,28 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     let entity = await db.query(uid).update({
       ...query,
       where: { id: entityId },
-      data: Object.assign(omitComponentData(model, validData), componentData),
+      data: updatePipeline(Object.assign(omitComponentData(model, validData), componentData), {
+        contentType: model,
+      }),
     });
 
     // TODO: upload the files then set the links in the entity like with compo to avoid making too many queries
     // FIXME: upload in components
     if (files && Object.keys(files).length > 0) {
       await this.uploadFiles(uid, entity, files);
-      entity = await this.findOne(uid, entity.id, { params });
+      entity = await this.findOne(uid, entity.id, wrappedParams);
     }
 
-    this.emitEvent(uid, ENTRY_UPDATE, entity);
+    await this.emitEvent(uid, ENTRY_UPDATE, entity);
 
     return entity;
   },
 
   async delete(uid, entityId, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'delete' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'delete' });
 
     // select / populate
-    const query = transformParamsToQuery(uid, pickSelectionParams(params));
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
     const entityToDelete = await db.query(uid).findOne({
       ...query,
@@ -225,18 +254,47 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     await deleteComponents(uid, entityToDelete);
     await db.query(uid).delete({ where: { id: entityToDelete.id } });
 
-    this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
+    await this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
 
     return entityToDelete;
   },
 
   // FIXME: used only for the CM to be removed
   async deleteMany(uid, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'delete' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'delete' });
 
     // select / populate
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
     return db.query(uid).deleteMany(query);
   },
+
+  load(uid, entity, field, params = {}) {
+    const { attributes } = strapi.getModel(uid);
+
+    const attribute = attributes[field];
+
+    const loadParams = {};
+
+    switch (attribute.type) {
+      case 'relation': {
+        Object.assign(loadParams, transformParamsToQuery(attribute.target, params));
+        break;
+      }
+      case 'component': {
+        Object.assign(loadParams, transformParamsToQuery(attribute.component, params));
+        break;
+      }
+      case 'dynamiczone': {
+        Object.assign(loadParams, transformParamsToQuery(null, params));
+        break;
+      }
+      case 'media': {
+        Object.assign(loadParams, transformParamsToQuery('plugin::upload.file', params));
+        break;
+      }
+    }
+
+    return db.query(uid).load(entity, field, loadParams);
+  },
 });

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

@@ -1,136 +1,94 @@
 'use strict';
 
-const _ = require('lodash');
-const { pick } = require('lodash/fp');
+const { pick, isNil, toNumber, isInteger } = require('lodash/fp');
+const { PaginationError } = require('@strapi/utils').errors;
 
 const {
   convertSortQueryParams,
   convertLimitQueryParams,
   convertStartQueryParams,
-} = require('@strapi/utils/lib/convert-rest-query-params');
+  convertPopulateQueryParams,
+  convertFiltersQueryParams,
+  convertFieldsQueryParams,
+  convertPublicationStateParams,
+} = require('@strapi/utils/lib/convert-query-params');
 
-const { contentTypes: contentTypesUtils } = require('@strapi/utils');
-
-const { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;
+const pickSelectionParams = pick(['fields', 'populate']);
 
-const transformParamsToQuery = (uid, params = {}) => {
-  const model = strapi.getModel(uid);
+const transformParamsToQuery = (uid, params) => {
+  // NOTE: can be a CT, a Compo or nothing in the case of polymorphism (DZ & morph relations)
+  const type = strapi.getModel(uid);
 
   const query = {};
 
-  // TODO: check invalid values add defaults ....
-
-  const {
-    start,
-    page,
-    pageSize,
-    limit,
-    sort,
-    filters,
-    fields,
-    populate,
-    publicationState,
-    _q,
-    _where,
-    ...rest
-  } = params;
-
-  if (_q) {
-    query._q = _q;
-  }
+  const { _q, sort, filters, fields, populate, page, pageSize, start, limit } = params;
 
-  if (page) {
-    query.page = Number(page);
-  }
-
-  if (pageSize) {
-    query.pageSize = Number(pageSize);
+  if (!isNil(_q)) {
+    query._q = _q;
   }
 
-  if (start) {
-    query.offset = convertStartQueryParams(start);
+  if (!isNil(sort)) {
+    query.orderBy = convertSortQueryParams(sort);
   }
 
-  if (limit) {
-    query.limit = convertLimitQueryParams(limit);
+  if (!isNil(filters)) {
+    query.where = convertFiltersQueryParams(filters);
   }
 
-  if (sort) {
-    query.orderBy = convertSortQueryParams(sort);
+  if (!isNil(fields)) {
+    query.select = convertFieldsQueryParams(fields);
   }
 
-  if (filters) {
-    query.where = filters;
+  if (!isNil(populate)) {
+    query.populate = convertPopulateQueryParams(populate);
   }
 
-  if (_where) {
-    query.where = {
-      $and: [_where].concat(query.where || []),
-    };
-  }
+  const isPagePagination = !isNil(page) || !isNil(pageSize);
+  const isOffsetPagination = !isNil(start) || !isNil(limit);
 
-  if (fields) {
-    // TODO: handle *.* syntax
-    query.select = _.castArray(fields);
+  if (isPagePagination && isOffsetPagination) {
+    throw new PaginationError(
+      'Invalid pagination attributes. You cannot use page and offset pagination in the same query'
+    );
   }
 
-  if (populate) {
-    // TODO: handle *.* syntax
-    const { populate } = params;
+  if (!isNil(page)) {
+    const pageVal = toNumber(page);
 
-    if (populate === '*') {
-      query.populate = true;
-    } else if (typeof populate === 'object') {
-      query.populate = populate;
-    } else {
-      query.populate = _.castArray(populate);
+    if (!isInteger(pageVal) || pageVal <= 0) {
+      throw new PaginationError(
+        `Invalid 'page' parameter. Expected an integer > 0, received: ${page}`
+      );
     }
-  }
 
-  // TODO: move to layer above ?
-  if (publicationState && contentTypesUtils.hasDraftAndPublish(model)) {
-    const { publicationState = 'live' } = params;
-
-    const liveClause = {
-      [PUBLISHED_AT_ATTRIBUTE]: {
-        $notNull: true,
-      },
-    };
+    query.page = pageVal;
+  }
 
-    if (publicationState === 'live') {
-      query.where = {
-        $and: [liveClause].concat(query.where || []),
-      };
+  if (!isNil(pageSize)) {
+    const pageSizeVal = toNumber(pageSize);
 
-      // TODO: propagate nested publicationState filter somehow
+    if (!isInteger(pageSizeVal) || pageSizeVal <= 0) {
+      throw new PaginationError(
+        `Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`
+      );
     }
-  }
 
-  const finalQuery = {
-    ...convertOldQuery(rest),
-    ...query,
-  };
+    query.pageSize = pageSizeVal;
+  }
 
-  return finalQuery;
-};
+  if (!isNil(start)) {
+    query.offset = convertStartQueryParams(start);
+  }
 
-// TODO: to remove once the front is migrated
-const convertOldQuery = params => {
-  const obj = {};
+  if (!isNil(limit)) {
+    query.limit = convertLimitQueryParams(limit);
+  }
 
-  Object.keys(params).forEach(key => {
-    if (key.startsWith('_')) {
-      obj[key.slice(1)] = params[key];
-    } else {
-      obj[key] = params[key];
-    }
-  });
+  convertPublicationStateParams(type, params, query);
 
-  return obj;
+  return query;
 };
 
-const pickSelectionParams = pick(['fields', 'populate']);
-
 module.exports = {
   transformParamsToQuery,
   pickSelectionParams,