@strapi/strapi 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/core/registries/services.js

@@ -1,14 +1,31 @@
 'use strict';
 
-const _ = require('lodash');
 const { pickBy, has } = require('lodash/fp');
 const { addNamespace, hasNamespace } = require('../utils');
 
+/**
+ * @typedef {import('./services').Service} Service
+ * @typedef {import('./services').ServiceFactory} ServiceFactory
+ */
+
 const servicesRegistry = strapi => {
   const services = {};
   const instantiatedServices = {};
 
   return {
+    /**
+     * Returns this list of registered services uids
+     * @returns {string[]}
+     */
+    keys() {
+      return Object.keys(services);
+    },
+
+    /**
+     * Returns the instance of a service. Instantiate the service if not already done
+     * @param {string} uid
+     * @returns {Service}
+     */
     get(uid) {
       if (instantiatedServices[uid]) {
         return instantiatedServices[uid];
@@ -16,21 +33,50 @@ const servicesRegistry = strapi => {
 
       const service = services[uid];
       if (service) {
-        instantiatedServices[uid] = service({ strapi });
+        instantiatedServices[uid] = typeof service === 'function' ? service({ strapi }) : service;
         return instantiatedServices[uid];
       }
-
-      return undefined;
     },
+
+    /**
+     * Returns a map with all the services in a namespace
+     * @param {string} namespace
+     * @returns {{ [key: string]: Service }}
+     */
     getAll(namespace) {
       const filteredServices = pickBy((_, uid) => hasNamespace(uid, namespace))(services);
 
-      return _.mapValues(filteredServices, (service, serviceUID) => this.get(serviceUID));
+      // create lazy accessor to avoid instantiating the services;
+      const map = {};
+      for (const uid in filteredServices) {
+        Object.defineProperty(map, uid, {
+          enumerable: true,
+          get: () => {
+            return this.get(uid);
+          },
+        });
+      }
+
+      return map;
     },
-    set(uid, value) {
-      instantiatedServices[uid] = value;
+
+    /**
+     * Registers a service
+     * @param {string} uid
+     * @param {Service} service
+     */
+    set(uid, service) {
+      services[uid] = service;
+      delete instantiatedServices[uid];
       return this;
     },
+
+    /**
+     * Registers a map of services for a specific namespace
+     * @param {string} namespace
+     * @param {{ [key: string]: Service|ServiceFactory }} newServices
+     * @returns
+     */
     add(namespace, newServices) {
       for (const serviceName in newServices) {
         const service = newServices[serviceName];
@@ -44,13 +90,23 @@ const servicesRegistry = strapi => {
 
       return this;
     },
-    extend(serviceUID, extendFn) {
-      const currentService = this.get(serviceUID);
+
+    /**
+     * Wraps a service to extend it
+     * @param {string} uid
+     * @param {(service: Service) => Service} extendFn
+     */
+    extend(uid, extendFn) {
+      const currentService = this.get(uid);
+
       if (!currentService) {
-        throw new Error(`Service ${serviceUID} doesn't exist`);
+        throw new Error(`Service ${uid} doesn't exist`);
       }
+
       const newService = extendFn(currentService);
-      instantiatedServices[serviceUID] = newService;
+      instantiatedServices[uid] = newService;
+
+      return this;
     },
   };
 };

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

@@ -1,12 +1,17 @@
 '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 = ({ service, sanitize, transformResponse }) => {
+const createCollectionTypeController = ({ contentType }) => {
+  const { uid } = contentType;
+
   return {
     /**
      * Retrieve records.
@@ -16,9 +21,10 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
     async find(ctx) {
       const { query } = ctx;
 
-      const { results, pagination } = await service.find(query);
+      const { results, pagination } = await strapi.service(uid).find(query);
+      const sanitizedResults = await this.sanitizeOutput(results, ctx);
 
-      return transformResponse(sanitize(results), { pagination });
+      return this.transformResponse(sanitizedResults, { pagination });
     },
 
     /**
@@ -30,9 +36,10 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
       const { id } = ctx.params;
       const { query } = ctx;
 
-      const entity = await service.findOne(id, query);
+      const entity = await strapi.service(uid).findOne(id, query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitize(entity));
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -45,9 +52,18 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
 
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.create({ ...query, data, files });
+      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({ ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
-      return transformResponse(sanitize(entity));
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -61,9 +77,18 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
 
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.update(id, { ...query, data, files });
+      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)
+        .update(id, { ...query, data: sanitizedInputData, files });
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -75,8 +100,10 @@ const createCollectionTypeController = ({ service, sanitize, transformResponse }
       const { id } = ctx.params;
       const { query } = ctx;
 
-      const entity = await service.delete(id, query);
-      return transformResponse(sanitize(entity));
+      const entity = await strapi.service(uid).delete(id, query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
   };
 };

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

@@ -0,0 +1,25 @@
+import { Context } from 'koa';
+
+type Response = object;
+
+interface BaseController {
+  transformResponse(data: object, meta: object): object;
+  sanitizeOutput(data: object, ctx: Context): Promise<object>;
+  sanitizeInput(data: object, ctx: Context): Promise<object>;
+}
+
+export interface SingleTypeController extends BaseController {
+  find(ctx: Context): Promise<Response>;
+  update(ctx: Context): Promise<Response>;
+  delete(ctx: Context): Promise<Response>;
+}
+
+export interface CollectionTypeController extends BaseController {
+  find(ctx: Context): Promise<Response>;
+  findOne(ctx: Context): Promise<Response>;
+  create(ctx: Context): Promise<Response>;
+  update(ctx: Context): Promise<Response>;
+  delete(ctx: Context): Promise<Response>;
+}
+
+export type Controller = SingleTypeController | CollectionTypeController;

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

@@ -1,26 +1,45 @@
 'use strict';
 
-const { sanitizeEntity, contentTypes } = require('@strapi/utils');
+const { getOr } = require('lodash/fp');
+
+const { contentTypes, sanitize } = require('@strapi/utils');
 
 const { transformResponse } = require('./transform');
 const createSingleTypeController = require('./single-type');
 const createCollectionTypeController = require('./collection-type');
 
-module.exports = ({ service, model }) => {
-  const ctx = {
-    model,
-    service,
+const getAuthFromKoaContext = getOr({}, 'state.auth');
+
+const createController = ({ contentType }) => {
+  const ctx = { contentType };
+
+  const proto = {
     transformResponse(data, meta) {
-      return transformResponse(data, meta, { contentType: model });
+      return transformResponse(data, meta, { contentType });
+    },
+
+    sanitizeOutput(data, ctx) {
+      const auth = getAuthFromKoaContext(ctx);
+
+      return sanitize.contentAPI.output(data, contentType, { auth });
     },
-    sanitize(data) {
-      return sanitizeEntity(data, { model: strapi.getModel(model.uid) });
+
+    sanitizeInput(data, ctx) {
+      const auth = getAuthFromKoaContext(ctx);
+
+      return sanitize.contentAPI.input(data, contentType, { auth });
     },
   };
 
-  if (contentTypes.isSingleType(model)) {
-    return createSingleTypeController(ctx);
+  let ctrl;
+
+  if (contentTypes.isSingleType(contentType)) {
+    ctrl = createSingleTypeController(ctx);
+  } else {
+    ctrl = createCollectionTypeController(ctx);
   }
 
-  return createCollectionTypeController(ctx);
+  return Object.assign(Object.create(proto), ctrl);
 };
+
+module.exports = { createController };

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

@@ -1,11 +1,16 @@
 '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 = ({ service, sanitize, transformResponse }) => {
+const createSingleTypeController = ({ contentType }) => {
+  const { uid } = contentType;
+
   return {
     /**
      * Retrieve single type content
@@ -14,8 +19,11 @@ const createSingleTypeController = ({ service, sanitize, transformResponse }) =>
      */
     async find(ctx) {
       const { query } = ctx;
-      const entity = await service.find(query);
-      return transformResponse(sanitize(entity));
+
+      const entity = await strapi.service(uid).find(query);
+      const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
+
+      return this.transformResponse(sanitizedEntity);
     },
 
     /**
@@ -27,16 +35,27 @@ const createSingleTypeController = ({ service, sanitize, transformResponse }) =>
       const { query } = ctx.request;
       const { data, files } = parseBody(ctx);
 
-      const entity = await service.createOrUpdate({ ...query, data, files });
+      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(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/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

@@ -22,14 +22,12 @@ 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 {
     async find(params = {}) {
-      const fetchParams = getFetchParams(params);
+      const fetchParams = this.getFetchParams(params);
 
       const paginationInfo = getPaginationInfo(fetchParams);
 
@@ -54,25 +52,23 @@ const createCollectionTypeService = ({ model, strapi, utils }) => {
     },
 
     findOne(entityId, params = {}) {
-      return strapi.entityService.findOne(uid, entityId, getFetchParams(params));
+      return strapi.entityService.findOne(uid, entityId, this.getFetchParams(params));
     },
 
     create(params = {}) {
       const { data } = params;
-      const sanitizedData = sanitizeInput(data);
 
-      if (hasDraftAndPublish(model)) {
-        setPublishedAt(sanitizedData);
+      if (hasDraftAndPublish(contentType)) {
+        setPublishedAt(data);
       }
 
-      return strapi.entityService.create(uid, { ...params, data: sanitizedData });
+      return strapi.entityService.create(uid, { ...params, data });
     },
 
     update(entityId, params = {}) {
       const { data } = params;
-      const sanitizedData = sanitizeInput(data);
 
-      return strapi.entityService.update(uid, entityId, { ...params, data: sanitizedData });
+      return strapi.entityService.update(uid, entityId, { ...params, data });
     },
 
     delete(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,14 +13,18 @@ const createCollectionTypeService = require('./collection-type');
  * @param {{ model: object, strapi: object }} context
  * @returns {object}
  */
-const createService = ({ model, strapi }) => {
-  const utils = createUtils({ model });
+const createService = ({ contentType }) => {
+  const proto = { getFetchParams };
+
+  let service;
 
-  if (isSingleType(model)) {
-    return createSingleTypeService({ model, strapi, utils });
+  if (isSingleType(contentType)) {
+    service = createSingleTypeService({ contentType });
+  } else {
+    service = createCollectionTypeService({ contentType });
   }
 
-  return createCollectionTypeService({ model, strapi, utils });
+  return Object.assign(Object.create(proto), service);
 };
 
 /**
@@ -38,17 +39,6 @@ const getFetchParams = (params = {}) => {
   };
 };
 
-/**
- * Mixins
- */
-const createUtils = ({ model }) => {
-  return {
-    // make sure to keep the call to getNonWritableAttributes dynamic
-    sanitizeInput: data => _.omit(data, getNonWritableAttributes(model)),
-    getFetchParams,
-  };
-};
-
 module.exports = {
   createService,
   getFetchParams,

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const { has, toNumber, isUndefined } = require('lodash/fp');
+const { ValidationError } = require('@strapi/utils').errors;
 
 /**
  * Default limit values from config
@@ -41,7 +42,9 @@ const shouldCount = params => {
       return false;
     }
 
-    throw new Error('Invalid withCount parameter. Expected "t","1","true","false","0","f"');
+    throw new ValidationError(
+      'Invalid withCount parameter. Expected "t","1","true","false","0","f"'
+    );
   }
 
   return Boolean(strapi.config.get('api.rest.withCount', true));
@@ -66,7 +69,9 @@ const getPaginationInfo = params => {
   }
 
   if (isOffset && isPaged) {
-    throw new Error('Invalid pagination parameters. Expected either start/limit or page/pageSize');
+    throw new ValidationError(
+      'Invalid pagination parameters. Expected either start/limit or page/pageSize'
+    );
   }
 
   if (isPagedPagination(pagination)) {

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

@@ -1,12 +1,16 @@
 '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
@@ -14,7 +18,7 @@ const createSingleTypeService = ({ model, strapi, utils }) => {
      * @return {Promise}
      */
     find(params = {}) {
-      return strapi.entityService.findMany(uid, getFetchParams(params));
+      return strapi.entityService.findMany(uid, this.getFetchParams(params));
     },
 
     /**
@@ -22,22 +26,19 @@ const createSingleTypeService = ({ model, strapi, utils }) => {
      *
      * @return {Promise}
      */
-    async createOrUpdate(params = {}) {
+    async createOrUpdate({ data, ...params } = {}) {
       const entity = await this.find(params);
 
-      const { data } = params;
-      const sanitizedData = sanitizeInput(data);
-
       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 });
+        return strapi.entityService.create(uid, { ...params, data });
       }
 
-      return strapi.entityService.update(uid, entity.id, { ...params, data: sanitizedData });
+      return strapi.entityService.update(uid, entity.id, { ...params, data });
     },
 
     /**