@strapi/strapi 4.0.0-next.6 → 4.0.0

package/lib/core-api/controller/single-type.js

@@ -1,11 +1,16 @@
 'use strict';
 
-const { transformResponse } = require('./transform');
+const { isObject } = require('lodash/fp');
+const { ValidationError } = require('@strapi/utils').errors;
+
+const { parseBody } = require('./transform');
 
 /**
  * Returns a single type controller to handle default core-api actions
  */
-const createSingleTypeController = ({ service, parseMultipartData, sanitize }) => {
+const createSingleTypeController = ({ contentType }) => {
+  const { uid } = contentType;
+
   return {
     /**
      * Retrieve single type content
@@ -14,8 +19,11 @@ const createSingleTypeController = ({ service, parseMultipartData, sanitize }) =
      */
     async find(ctx) {
       const { query } = ctx;
-      const entity = await service.find({ params: query });
-      return transformResponse(sanitize(entity));
+
+      const entity = await strapi.service(uid).find(query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -24,24 +32,30 @@ const createSingleTypeController = ({ service, parseMultipartData, sanitize }) =
      * @return {Object}
      */
     async update(ctx) {
-      const { body, query } = ctx.request;
-
-      let entity;
-      if (ctx.is('multipart')) {
-        const { data, files } = parseMultipartData(ctx);
-        entity = await service.createOrUpdate({ params: query, data, files });
-      } else {
-        entity = await service.createOrUpdate({ params: query, data: body });
+      const { query } = ctx.request;
+      const { data, files } = parseBody(ctx);
+
+      if (!isObject(data)) {
+        throw new ValidationError('Missing "data" payload in the request body');
       }
 
-      return transformResponse(sanitize(entity));
+      const sanitizedInputData = await this.sanitizeInput(data, ctx);
+
+      const entity = await strapi
+        .service(uid)
+        .createOrUpdate({ ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
 
     async delete(ctx) {
       const { query } = ctx;
 
-      const entity = await service.delete({ params: query });
-      return transformResponse(sanitize(entity));
+      const entity = await strapi.service(uid).delete(query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
   };
 };

package/lib/core-api/controller/transform.js

@@ -1,41 +1,97 @@
 'use strict';
 
 const { isNil, isPlainObject } = require('lodash/fp');
+const { parseMultipartData } = require('@strapi/utils');
 
-const transformResponse = (resource, meta = {}) => {
+const parseBody = ctx => {
+  if (ctx.is('multipart')) {
+    return parseMultipartData(ctx);
+  }
+
+  const { data } = ctx.request.body || {};
+
+  return { data };
+};
+
+const transformResponse = (resource, meta = {}, { contentType } = {}) => {
   if (isNil(resource)) {
     return resource;
   }
 
   return {
-    data: transformEntry(resource),
+    data: transformEntry(resource, contentType),
     meta,
   };
 };
 
-const transformEntry = entry => {
+const transformComponent = (data, component) => {
+  if (Array.isArray(data)) {
+    return data.map(datum => transformComponent(datum, component));
+  }
+
+  const res = transformEntry(data, component);
+
+  if (isNil(res)) {
+    return res;
+  }
+
+  const { id, attributes } = res;
+  return { id, ...attributes };
+};
+
+const transformEntry = (entry, type) => {
   if (isNil(entry)) {
     return entry;
   }
 
   if (Array.isArray(entry)) {
-    return entry.map(singleEntry => transformEntry(singleEntry));
+    return entry.map(singleEntry => transformEntry(singleEntry, type));
   }
 
   if (!isPlainObject(entry)) {
     throw new Error('Entry must be an object');
   }
 
-  const { id, ...attributes } = entry;
+  const { id, ...properties } = entry;
+
+  const attributeValues = {};
+
+  for (const key in properties) {
+    const property = properties[key];
+    const attribute = type && type.attributes[key];
+
+    if (attribute && attribute.type === 'relation') {
+      const data = transformEntry(property, strapi.contentType(attribute.target));
+
+      attributeValues[key] = { data };
+    } else if (attribute && attribute.type === 'component') {
+      attributeValues[key] = transformComponent(property, strapi.components[attribute.component]);
+    } else if (attribute && attribute.type === 'dynamiczone') {
+      if (isNil(property)) {
+        attributeValues[key] = property;
+      }
+
+      attributeValues[key] = property.map(subProperty => {
+        return transformComponent(subProperty, strapi.components[subProperty.__component]);
+      });
+    } else if (attribute && attribute.type === 'media') {
+      const data = transformEntry(property, strapi.contentType('plugin::upload.file'));
+
+      attributeValues[key] = { data };
+    } else {
+      attributeValues[key] = property;
+    }
+  }
 
   return {
     id,
-    attributes,
+    attributes: attributeValues,
     // NOTE: not necessary for now
     // meta: {},
   };
 };
 
 module.exports = {
+  parseBody,
   transformResponse,
 };

package/lib/core-api/routes/index.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { isSingleType } = require('@strapi/utils').contentTypes;
+
+const createRoutes = ({ contentType }) => {
+  if (isSingleType(contentType)) {
+    return getSingleTypeRoutes(contentType);
+  }
+
+  return getCollectionTypeRoutes(contentType);
+};
+
+const getSingleTypeRoutes = ({ uid, info }) => {
+  return {
+    find: {
+      method: 'GET',
+      path: `/${info.singularName}`,
+      handler: `${uid}.find`,
+      config: {},
+    },
+    update: {
+      method: 'PUT',
+      path: `/${info.singularName}`,
+      handler: `${uid}.update`,
+      config: {},
+    },
+    delete: {
+      method: 'DELETE',
+      path: `/${info.singularName}`,
+      handler: `${uid}.delete`,
+      config: {},
+    },
+  };
+};
+
+const getCollectionTypeRoutes = ({ uid, info }) => {
+  return {
+    find: {
+      method: 'GET',
+      path: `/${info.pluralName}`,
+      handler: `${uid}.find`,
+      config: {},
+    },
+    findOne: {
+      method: 'GET',
+      path: `/${info.pluralName}/:id`,
+      handler: `${uid}.findOne`,
+      config: {},
+    },
+    create: {
+      method: 'POST',
+      path: `/${info.pluralName}`,
+      handler: `${uid}.create`,
+      config: {},
+    },
+    update: {
+      method: 'PUT',
+      path: `/${info.pluralName}/:id`,
+      handler: `${uid}.update`,
+      config: {},
+    },
+    delete: {
+      method: 'DELETE',
+      path: `/${info.pluralName}/:id`,
+      handler: `${uid}.delete`,
+      config: {},
+    },
+  };
+};
+
+module.exports = { createRoutes };

package/lib/core-api/service/collection-type.js

@@ -7,6 +7,13 @@ const {
   constants: { PUBLISHED_AT_ATTRIBUTE },
 } = require('@strapi/utils').contentTypes;
 
+const {
+  getPaginationInfo,
+  convertPagedToStartLimit,
+  shouldCount,
+  transformPaginationResponse,
+} = require('./pagination');
+
 const setPublishedAt = data => {
   data[PUBLISHED_AT_ATTRIBUTE] = propOr(new Date(), PUBLISHED_AT_ATTRIBUTE, data);
 };
@@ -15,42 +22,57 @@ const setPublishedAt = data => {
  *
  * Returns a collection type service to handle default core-api actions
  */
-const createCollectionTypeService = ({ model, strapi, utils }) => {
-  const { uid } = model;
-
-  const { sanitizeInput, getFetchParams } = utils;
+const createCollectionTypeService = ({ contentType }) => {
+  const { uid } = contentType;
 
   return {
-    find(opts = {}) {
-      const params = getFetchParams(opts.params);
+    async find(params = {}) {
+      const fetchParams = this.getFetchParams(params);
 
-      return strapi.entityService.findPage(uid, { params });
-    },
+      const paginationInfo = getPaginationInfo(fetchParams);
+
+      const results = await strapi.entityService.findMany(uid, {
+        ...fetchParams,
+        ...convertPagedToStartLimit(paginationInfo),
+      });
 
-    findOne(entityId, opts = {}) {
-      const params = getFetchParams(opts.params);
+      if (shouldCount(fetchParams)) {
+        const count = await strapi.entityService.count(uid, { ...fetchParams, ...paginationInfo });
+
+        return {
+          results,
+          pagination: transformPaginationResponse(paginationInfo, count),
+        };
+      }
+
+      return {
+        results,
+        pagination: paginationInfo,
+      };
+    },
 
-      return strapi.entityService.findOne(uid, entityId, { params });
+    findOne(entityId, params = {}) {
+      return strapi.entityService.findOne(uid, entityId, this.getFetchParams(params));
     },
 
-    create({ params, data, files } = {}) {
-      const sanitizedData = sanitizeInput(data);
+    create(params = {}) {
+      const { data } = params;
 
-      if (hasDraftAndPublish(model)) {
-        setPublishedAt(sanitizedData);
+      if (hasDraftAndPublish(contentType)) {
+        setPublishedAt(data);
       }
 
-      return strapi.entityService.create(uid, { params, data: sanitizedData, files });
+      return strapi.entityService.create(uid, { ...params, data });
     },
 
-    update(entityId, { params, data, files } = {}) {
-      const sanitizedData = sanitizeInput(data);
+    update(entityId, params = {}) {
+      const { data } = params;
 
-      return strapi.entityService.update(uid, entityId, { params, data: sanitizedData, files });
+      return strapi.entityService.update(uid, entityId, { ...params, data });
     },
 
-    delete(entityId, { params } = {}) {
-      return strapi.entityService.delete(uid, entityId, { params });
+    delete(entityId, params = {}) {
+      return strapi.entityService.delete(uid, entityId, params);
     },
   };
 };

package/lib/core-api/service/index.d.ts

@@ -0,0 +1,21 @@
+type Entity = object;
+
+interface BaseService {
+  getFetchParams(params: object): object;
+}
+
+export interface SingleTypeService extends BaseService {
+  find(params: object): Promise<Entity>;
+  createOrUpdate(params: object): Promise<Entity>;
+  delete(params: object): Promise<Entity>;
+}
+
+export interface CollectionTypeService extends BaseService {
+  find(params: object): Promise<Entity[]>;
+  findOne(params: object): Promise<Entity>;
+  create(params: object): Promise<Entity>;
+  update(params: object): Promise<Entity>;
+  delete(params: object): Promise<Entity>;
+}
+
+export type Service = SingleTypeService | CollectionTypeService;

package/lib/core-api/service/index.js

@@ -1,10 +1,7 @@
 'use strict';
 
-const _ = require('lodash');
-
 const {
   isSingleType,
-  getNonWritableAttributes,
   constants: { DP_PUB_STATE_LIVE },
 } = require('@strapi/utils').contentTypes;
 
@@ -16,62 +13,18 @@ const createCollectionTypeService = require('./collection-type');
  * @param {{ model: object, strapi: object }} context
  * @returns {object}
  */
-const createService = ({ model, strapi }) => {
-  const utils = createUtils({ model });
-
-  if (isSingleType(model)) {
-    return createSingleTypeService({ model, strapi, utils });
-  }
+const createService = ({ contentType }) => {
+  const proto = { getFetchParams };
 
-  return createCollectionTypeService({ model, strapi, utils });
-};
-
-/**
- * Default limit values from config
- * @return {{maxLimit: number, defaultLimit: number}}
- */
-const getLimitConfigDefaults = () => ({
-  defaultLimit: _.toNumber(strapi.config.get('api.rest.defaultLimit', 100)),
-  maxLimit: _.toNumber(strapi.config.get('api.rest.maxLimit')) || null,
-});
+  let service;
 
-/**
- * if there is max limit set and limit exceeds this number, return configured max limit
- * @param {number} limit - limit you want to cap
- * @param {number?} maxLimit - maxlimit used has capping
- * @returns {number}
- */
-const applyMaxLimit = (limit, maxLimit) => {
-  if (maxLimit && (limit === -1 || limit > maxLimit)) {
-    return maxLimit;
+  if (isSingleType(contentType)) {
+    service = createSingleTypeService({ contentType });
+  } else {
+    service = createCollectionTypeService({ contentType });
   }
 
-  return limit;
-};
-
-const applyDefaultPagination = params => {
-  const { defaultLimit, maxLimit } = getLimitConfigDefaults();
-
-  if (_.isUndefined(params.pagination) || !_.isPlainObject(params.pagination)) {
-    return {
-      limit: defaultLimit,
-    };
-  }
-
-  const { pagination } = params;
-
-  if (!_.isUndefined(pagination.pageSize)) {
-    return {
-      page: pagination.page,
-      pageSize: applyMaxLimit(_.toNumber(pagination.pageSize), maxLimit),
-    };
-  }
-
-  const limit = _.isUndefined(pagination.limit) ? defaultLimit : _.toNumber(pagination.limit);
-  return {
-    start: pagination.start,
-    limit: applyMaxLimit(limit, maxLimit),
-  };
+  return Object.assign(Object.create(proto), service);
 };
 
 /**
@@ -83,18 +36,6 @@ const getFetchParams = (params = {}) => {
   return {
     publicationState: DP_PUB_STATE_LIVE,
     ...params,
-    pagination: applyDefaultPagination(params),
-  };
-};
-
-/**
- * Mixins
- */
-const createUtils = ({ model }) => {
-  return {
-    // make sure to keep the call to getNonWritableAttributes dynamic
-    sanitizeInput: data => _.omit(data, getNonWritableAttributes(model)),
-    getFetchParams,
   };
 };
 

package/lib/core-api/service/pagination.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const { has, toNumber, isUndefined } = require('lodash/fp');
+const { ValidationError } = require('@strapi/utils').errors;
+
+/**
+ * Default limit values from config
+ * @return {{maxLimit: number, defaultLimit: number}}
+ */
+const getLimitConfigDefaults = () => ({
+  defaultLimit: toNumber(strapi.config.get('api.rest.defaultLimit', 25)),
+  maxLimit: toNumber(strapi.config.get('api.rest.maxLimit')) || null,
+});
+
+/**
+ * if there is max limit set and limit exceeds this number, return configured max limit
+ * @param {number} limit - limit you want to cap
+ * @param {number?} maxLimit - maxlimit used has capping
+ * @returns {number}
+ */
+const applyMaxLimit = (limit, maxLimit) => {
+  if (maxLimit && (limit === -1 || limit > maxLimit)) {
+    return maxLimit;
+  }
+
+  return limit;
+};
+
+const shouldCount = params => {
+  if (has('pagination.withCount', params)) {
+    const { withCount } = params.pagination;
+
+    if (typeof withCount === 'boolean') {
+      return withCount;
+    }
+
+    if (['true', 't', '1', 1].includes(withCount)) {
+      return true;
+    }
+
+    if (['false', 'f', '0', 0].includes(withCount)) {
+      return false;
+    }
+
+    throw new ValidationError(
+      'Invalid withCount parameter. Expected "t","1","true","false","0","f"'
+    );
+  }
+
+  return Boolean(strapi.config.get('api.rest.withCount', true));
+};
+
+const isOffsetPagination = pagination => has('start', pagination) || has('limit', pagination);
+const isPagedPagination = pagination => has('page', pagination) || has('pageSize', pagination);
+
+const getPaginationInfo = params => {
+  const { defaultLimit, maxLimit } = getLimitConfigDefaults();
+
+  const { pagination } = params;
+
+  const isPaged = isPagedPagination(pagination);
+  const isOffset = isOffsetPagination(pagination);
+
+  if (!isPaged && !isOffset) {
+    return {
+      page: 1,
+      pageSize: defaultLimit,
+    };
+  }
+
+  if (isOffset && isPaged) {
+    throw new ValidationError(
+      'Invalid pagination parameters. Expected either start/limit or page/pageSize'
+    );
+  }
+
+  if (isPagedPagination(pagination)) {
+    const pageSize = isUndefined(pagination.pageSize)
+      ? defaultLimit
+      : Math.max(1, toNumber(pagination.pageSize));
+
+    return {
+      page: Math.max(1, toNumber(pagination.page || 1)),
+      pageSize: applyMaxLimit(pageSize, maxLimit),
+    };
+  }
+
+  const limit = isUndefined(pagination.limit)
+    ? defaultLimit
+    : Math.max(1, toNumber(pagination.limit));
+
+  return {
+    start: Math.max(0, toNumber(pagination.start || 0)),
+    limit: applyMaxLimit(limit, maxLimit),
+  };
+};
+
+const convertPagedToStartLimit = pagination => {
+  if (isPagedPagination(pagination)) {
+    const { page, pageSize } = pagination;
+    return {
+      start: (page - 1) * pageSize,
+      limit: pageSize,
+    };
+  }
+
+  return pagination;
+};
+
+const transformPaginationResponse = (paginationInfo, count) => {
+  if (paginationInfo.page) {
+    return {
+      ...paginationInfo,
+      pageCount: Math.ceil(count / paginationInfo.pageSize),
+      total: count,
+    };
+  }
+
+  return {
+    ...paginationInfo,
+    total: count,
+  };
+};
+
+module.exports = {
+  getPaginationInfo,
+  convertPagedToStartLimit,
+  transformPaginationResponse,
+  shouldCount,
+};

package/lib/core-api/service/single-type.js

@@ -1,20 +1,24 @@
 'use strict';
 
+const { ValidationError } = require('@strapi/utils').errors;
+
 /**
  * Returns a single type service to handle default core-api actions
  */
-const createSingleTypeService = ({ model, strapi, utils }) => {
-  const { uid } = model;
-  const { sanitizeInput, getFetchParams } = utils;
+const createSingleTypeService = ({ contentType }) => {
+  const { uid } = contentType;
 
+  /**
+   * @type {import('./').SingleTypeService}
+   */
   return {
     /**
      * Returns singleType content
      *
      * @return {Promise}
      */
-    find({ params } = {}) {
-      return strapi.entityService.find(uid, { params: getFetchParams(params) });
+    find(params = {}) {
+      return strapi.entityService.findMany(uid, this.getFetchParams(params));
     },
 
     /**
@@ -22,25 +26,19 @@ const createSingleTypeService = ({ model, strapi, utils }) => {
      *
      * @return {Promise}
      */
-    async createOrUpdate({ params, data, files } = {}) {
-      const entity = await this.find({ params });
-
-      const sanitizedData = sanitizeInput(data);
+    async createOrUpdate({ data, ...params } = {}) {
+      const entity = await this.find(params);
 
       if (!entity) {
         const count = await strapi.query(uid).count();
         if (count >= 1) {
-          throw strapi.errors.badRequest('singleType.alreadyExists');
+          throw new ValidationError('singleType.alreadyExists');
         }
 
-        return strapi.entityService.create(uid, { params, data: sanitizedData, files });
-      } else {
-        return strapi.entityService.update(uid, entity.id, {
-          params,
-          data: sanitizedData,
-          files,
-        });
+        return strapi.entityService.create(uid, { ...params, data });
       }
+
+      return strapi.entityService.update(uid, entity.id, { ...params, data });
     },
 
     /**
@@ -48,8 +46,8 @@ const createSingleTypeService = ({ model, strapi, utils }) => {
      *
      * @return {Promise}
      */
-    async delete({ params } = {}) {
-      const entity = await this.find({ params });
+    async delete(params = {}) {
+      const entity = await this.find(params);
 
       if (!entity) return;