@strapi/strapi 4.14.0-alpha.0 → 4.14.0

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

@@ -1,115 +0,0 @@
-'use strict';
-
-const { isObject } = require('lodash/fp');
-const { ValidationError } = require('@strapi/utils').errors;
-
-const { parseBody } = require('./transform');
-
-/**
- *
- * Returns a collection type controller to handle default core-api actions
- */
-const createCollectionTypeController = ({ contentType }) => {
-  const { uid } = contentType;
-
-  return {
-    /**
-     * Retrieve records.
-     *
-     * @return {Object|Array}
-     */
-    async find(ctx) {
-      await this.validateQuery(ctx);
-      const sanitizedQuery = await this.sanitizeQuery(ctx);
-
-      const { results, pagination } = await strapi.service(uid).find(sanitizedQuery);
-      const sanitizedResults = await this.sanitizeOutput(results, ctx);
-      return this.transformResponse(sanitizedResults, { pagination });
-    },
-
-    /**
-     * Retrieve a record.
-     *
-     * @return {Object}
-     */
-    async findOne(ctx) {
-      const { id } = ctx.params;
-      await this.validateQuery(ctx);
-      const sanitizedQuery = await this.sanitizeQuery(ctx);
-
-      const entity = await strapi.service(uid).findOne(id, sanitizedQuery);
-      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
-
-      return this.transformResponse(sanitizedEntity);
-    },
-
-    /**
-     * Create a record.
-     *
-     * @return {Object}
-     */
-    async create(ctx) {
-      await this.validateQuery(ctx);
-      const sanitizedQuery = await this.sanitizeQuery(ctx);
-
-      const { data, files } = parseBody(ctx);
-
-      if (!isObject(data)) {
-        throw new ValidationError('Missing "data" payload in the request body');
-      }
-
-      const sanitizedInputData = await this.sanitizeInput(data, ctx);
-
-      const entity = await strapi
-        .service(uid)
-        .create({ ...sanitizedQuery, data: sanitizedInputData, files });
-      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
-
-      return this.transformResponse(sanitizedEntity);
-    },
-
-    /**
-     * Update a record.
-     *
-     * @return {Object}
-     */
-    async update(ctx) {
-      const { id } = ctx.params;
-      await this.validateQuery(ctx);
-      const sanitizedQuery = await this.sanitizeQuery(ctx);
-
-      const { data, files } = parseBody(ctx);
-
-      if (!isObject(data)) {
-        throw new ValidationError('Missing "data" payload in the request body');
-      }
-
-      const sanitizedInputData = await this.sanitizeInput(data, ctx);
-
-      const entity = await strapi
-        .service(uid)
-        .update(id, { ...sanitizedQuery, data: sanitizedInputData, files });
-      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
-
-      return this.transformResponse(sanitizedEntity);
-    },
-
-    /**
-     * Destroy a record.
-     *
-     * @return {Object}
-     */
-    async delete(ctx) {
-      const { id } = ctx.params;
-      await this.validateQuery(ctx);
-      const sanitizedQuery = await this.sanitizeQuery(ctx);
-
-      const entity = await strapi.service(uid).delete(id, sanitizedQuery);
-      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
-
-      return this.transformResponse(sanitizedEntity);
-    },
-  };
-};
-
-module.exports = createCollectionTypeController;

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

@@ -1,63 +0,0 @@
-'use strict';
-
-const { getOr } = require('lodash/fp');
-
-const { contentTypes, sanitize, validate } = require('@strapi/utils');
-
-const { transformResponse } = require('./transform');
-const createSingleTypeController = require('./single-type');
-const createCollectionTypeController = require('./collection-type');
-
-const getAuthFromKoaContext = getOr({}, 'state.auth');
-
-const createController = ({ contentType }) => {
-  const ctx = { contentType };
-
-  const proto = {
-    transformResponse(data, meta) {
-      return transformResponse(data, meta, { contentType });
-    },
-
-    async sanitizeOutput(data, ctx) {
-      const auth = getAuthFromKoaContext(ctx);
-
-      return sanitize.contentAPI.output(data, contentType, { auth });
-    },
-
-    async sanitizeInput(data, ctx) {
-      const auth = getAuthFromKoaContext(ctx);
-
-      return sanitize.contentAPI.input(data, contentType, { auth });
-    },
-
-    async sanitizeQuery(ctx) {
-      const auth = getAuthFromKoaContext(ctx);
-
-      return sanitize.contentAPI.query(ctx.query, contentType, { auth });
-    },
-
-    async validateQuery(ctx) {
-      const auth = getAuthFromKoaContext(ctx);
-
-      return validate.contentAPI.query(ctx.query, contentType, { auth });
-    },
-
-    async validateInput(data, ctx) {
-      const auth = getAuthFromKoaContext(ctx);
-
-      return validate.contentAPI.input(data, contentType, { auth });
-    },
-  };
-
-  let ctrl;
-
-  if (contentTypes.isSingleType(contentType)) {
-    ctrl = createSingleTypeController(ctx);
-  } else {
-    ctrl = createCollectionTypeController(ctx);
-  }
-
-  return Object.assign(Object.create(proto), ctrl);
-};
-
-module.exports = { createController };

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

@@ -1,65 +0,0 @@
-'use strict';
-
-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 = ({ contentType }) => {
-  const { uid } = contentType;
-
-  return {
-    /**
-     * Retrieve single type content
-     *
-     * @return {Object|Array}
-     */
-    async find(ctx) {
-      await this.validateQuery(ctx);
-      const sanitizedQuery = await this.sanitizeQuery(ctx);
-
-      const entity = await strapi.service(uid).find(sanitizedQuery);
-
-      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
-
-      return this.transformResponse(sanitizedEntity);
-    },
-
-    /**
-     * create or update single type content.
-     *
-     * @return {Object}
-     */
-    async update(ctx) {
-      const { query } = ctx.request;
-      const { data, files } = parseBody(ctx);
-
-      if (!isObject(data)) {
-        throw new ValidationError('Missing "data" payload in the request body');
-      }
-
-      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 strapi.service(uid).delete(query);
-      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
-
-      return this.transformResponse(sanitizedEntity);
-    },
-  };
-};
-
-module.exports = createSingleTypeController;

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

@@ -1,97 +0,0 @@
-'use strict';
-
-const { isNil, isPlainObject } = require('lodash/fp');
-const { parseMultipartData } = require('@strapi/utils');
-
-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, contentType),
-    meta,
-  };
-};
-
-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, type));
-  }
-
-  if (!isPlainObject(entry)) {
-    throw new Error('Entry must be an object');
-  }
-
-  const { id, ...properties } = entry;
-
-  const attributeValues = {};
-
-  for (const key of Object.keys(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: attributeValues,
-    // NOTE: not necessary for now
-    // meta: {},
-  };
-};
-
-module.exports = {
-  parseBody,
-  transformResponse,
-};

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

@@ -1,71 +0,0 @@
-'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

@@ -1,80 +0,0 @@
-'use strict';
-
-const { propOr } = require('lodash/fp');
-
-const {
-  hasDraftAndPublish,
-  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);
-};
-
-/**
- *
- * Returns a collection type service to handle default core-api actions
- */
-const createCollectionTypeService = ({ contentType }) => {
-  const { uid } = contentType;
-
-  return {
-    async find(params = {}) {
-      const fetchParams = this.getFetchParams(params);
-
-      const paginationInfo = getPaginationInfo(fetchParams);
-
-      const results = await strapi.entityService.findMany(uid, {
-        ...fetchParams,
-        ...convertPagedToStartLimit(paginationInfo),
-      });
-
-      if (shouldCount(fetchParams)) {
-        const count = await strapi.entityService.count(uid, { ...fetchParams, ...paginationInfo });
-
-        return {
-          results,
-          pagination: transformPaginationResponse(paginationInfo, count),
-        };
-      }
-
-      return {
-        results,
-        pagination: paginationInfo,
-      };
-    },
-
-    findOne(entityId, params = {}) {
-      return strapi.entityService.findOne(uid, entityId, this.getFetchParams(params));
-    },
-
-    create(params = {}) {
-      const { data } = params;
-
-      if (hasDraftAndPublish(contentType)) {
-        setPublishedAt(data);
-      }
-
-      return strapi.entityService.create(uid, { ...params, data });
-    },
-
-    update(entityId, params = {}) {
-      const { data } = params;
-
-      return strapi.entityService.update(uid, entityId, { ...params, data });
-    },
-
-    delete(entityId, params = {}) {
-      return strapi.entityService.delete(uid, entityId, params);
-    },
-  };
-};
-
-module.exports = createCollectionTypeService;

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

@@ -1,45 +0,0 @@
-'use strict';
-
-const {
-  isSingleType,
-  constants: { DP_PUB_STATE_LIVE },
-} = require('@strapi/utils').contentTypes;
-
-const createSingleTypeService = require('./single-type');
-const createCollectionTypeService = require('./collection-type');
-
-/**
- * Returns a core api for the provided model
- * @param {{ model: object, strapi: object }} context
- * @returns {object}
- */
-const createService = ({ contentType }) => {
-  const proto = { getFetchParams };
-
-  let service;
-
-  if (isSingleType(contentType)) {
-    service = createSingleTypeService({ contentType });
-  } else {
-    service = createCollectionTypeService({ contentType });
-  }
-
-  return Object.assign(Object.create(proto), service);
-};
-
-/**
- * Create default fetch params
- * @param {*} params
- * @returns
- */
-const getFetchParams = (params = {}) => {
-  return {
-    publicationState: DP_PUB_STATE_LIVE,
-    ...params,
-  };
-};
-
-module.exports = {
-  createService,
-  getFetchParams,
-};

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

@@ -1,125 +0,0 @@
-'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,
-});
-
-/**
- * Should maxLimit be used as the limit or not
- * @param {number} limit - limit you want to cap
- * @param {number?} maxLimit - maxlimit used has capping
- * @returns {boolean}
- */
-const shouldApplyMaxLimit = (limit, maxLimit = null, { isPagedPagination = false } = {}) =>
-  (!isPagedPagination && limit === -1) || (maxLimit && limit > maxLimit);
-
-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: shouldApplyMaxLimit(pageSize, maxLimit, { isPagedPagination: true })
-        ? maxLimit
-        : Math.max(1, pageSize),
-    };
-  }
-
-  const limit = isUndefined(pagination.limit) ? defaultLimit : toNumber(pagination.limit);
-
-  return {
-    start: Math.max(0, toNumber(pagination.start || 0)),
-    limit: shouldApplyMaxLimit(limit, maxLimit) ? maxLimit || -1 : Math.max(1, limit),
-  };
-};
-
-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,
-};