@strapi/strapi 4.0.0-next.9 → 4.0.0

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

@@ -24,13 +24,28 @@ const transformResponse = (resource, meta = {}, { contentType } = {}) => {
   };
 };
 
-const transformEntry = (entry, contentType) => {
+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, contentType));
+    return entry.map(singleEntry => transformEntry(singleEntry, type));
   }
 
   if (!isPlainObject(entry)) {
@@ -43,12 +58,22 @@ const transformEntry = (entry, contentType) => {
 
   for (const key in properties) {
     const property = properties[key];
-    const attribute = contentType && contentType.attributes[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'));
 

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,25 +22,22 @@ 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(opts = {}) {
-      const params = getFetchParams(opts.params);
+    async find(params = {}) {
+      const fetchParams = this.getFetchParams(params);
 
-      const paginationInfo = getPaginationInfo(params);
+      const paginationInfo = getPaginationInfo(fetchParams);
 
-      const results = await strapi.entityService.find(uid, {
-        params: { ...params, ...convertPagedToStartLimit(paginationInfo) },
+      const results = await strapi.entityService.findMany(uid, {
+        ...fetchParams,
+        ...convertPagedToStartLimit(paginationInfo),
       });
 
-      if (shouldCount(params)) {
-        const count = await strapi.entityService.count(uid, {
-          params: { ...params, ...paginationInfo },
-        });
+      if (shouldCount(fetchParams)) {
+        const count = await strapi.entityService.count(uid, { ...fetchParams, ...paginationInfo });
 
         return {
           results,
@@ -54,30 +51,28 @@ const createCollectionTypeService = ({ model, strapi, utils }) => {
       };
     },
 
-    findOne(entityId, opts = {}) {
-      const params = getFetchParams(opts.params);
-
-      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,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,21 +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 } = {}) {
-      const normalizedParams = getFetchParams(params);
-      return strapi.entityService.find(uid, { params: normalizedParams });
+    find(params = {}) {
+      return strapi.entityService.findMany(uid, this.getFetchParams(params));
     },
 
     /**
@@ -23,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 });
     },
 
     /**
@@ -49,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;
 

package/lib/factories.d.ts

@@ -0,0 +1,48 @@
+import { Service } from './core-api/service';
+import { Controller } from './core-api/controller';
+import { Middleware } from './middlewares';
+import { Policy } from './core/registries/policies';
+
+type ControllerConfig = Controller;
+
+type ServiceConfig = Service;
+
+type HandlerConfig = {
+  auth: false | { scope: string[] };
+  policies: Array<string | Policy>;
+  middlewares: Array<string | Middleware>;
+};
+
+type SingleTypeRouterConfig = {
+  find: HandlerConfig;
+  update: HandlerConfig;
+  delete: HandlerConfig;
+};
+
+type CollectionTypeRouterConfig = {
+  find: HandlerConfig;
+  findOne: HandlerConfig;
+  create: HandlerConfig;
+  update: HandlerConfig;
+  delete: HandlerConfig;
+};
+
+type RouterConfig = {
+  prefix: string;
+  only: string[];
+  except: string[];
+  config: SingleTypeRouterConfig | CollectionTypeRouterConfig;
+};
+
+interface Route {
+  method: string;
+  path: string;
+}
+interface Router {
+  prefix: string;
+  routes: Route[];
+}
+
+export function createCoreRouter(uid: string, cfg: RouterConfig): () => Router;
+export function createCoreController(uid: string, cfg: ControllerConfig): () => Controller;
+export function createCoreService(uid: string, cfg: ServiceConfig): () => Service;

package/lib/factories.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { pipe, omit, pick } = require('lodash/fp');
+
+const { createController } = require('./core-api/controller');
+const { createService } = require('./core-api/service');
+const { createRoutes } = require('./core-api/routes');
+
+const createCoreController = (uid, cfg = {}) => {
+  return ({ strapi }) => {
+    const baseController = createController({
+      contentType: strapi.contentType(uid),
+    });
+
+    let userCtrl = typeof cfg === 'function' ? cfg({ strapi }) : cfg;
+
+    for (const methodName of Object.keys(baseController)) {
+      if (userCtrl[methodName] === undefined) {
+        userCtrl[methodName] = baseController[methodName];
+      }
+    }
+
+    Object.setPrototypeOf(userCtrl, baseController);
+    return userCtrl;
+  };
+};
+
+const createCoreService = (uid, cfg = {}) => {
+  return ({ strapi }) => {
+    const baseService = createService({
+      contentType: strapi.contentType(uid),
+    });
+
+    let userService = typeof cfg === 'function' ? cfg({ strapi }) : cfg;
+
+    for (const methodName of Object.keys(baseService)) {
+      if (userService[methodName] === undefined) {
+        userService[methodName] = baseService[methodName];
+      }
+    }
+
+    Object.setPrototypeOf(userService, baseService);
+    return userService;
+  };
+};
+
+const createCoreRouter = (uid, cfg = {}) => {
+  const { prefix, config = {}, only, except } = cfg;
+  let routes;
+
+  return {
+    get prefix() {
+      return prefix;
+    },
+    get routes() {
+      if (!routes) {
+        const contentType = strapi.contentType(uid);
+
+        const defaultRoutes = createRoutes({ contentType });
+
+        Object.keys(defaultRoutes).forEach(routeName => {
+          const defaultRoute = defaultRoutes[routeName];
+
+          Object.assign(defaultRoute.config, config[routeName] || {});
+        });
+
+        const selectedRoutes = pipe(
+          routes => (except ? omit(except, routes) : routes),
+          routes => (only ? pick(only, routes) : routes)
+        )(defaultRoutes);
+
+        routes = Object.values(selectedRoutes);
+      }
+
+      return routes;
+    },
+  };
+};
+
+module.exports = {
+  createCoreController,
+  createCoreService,
+  createCoreRouter,
+};

package/lib/index.d.ts

@@ -1,40 +1,15 @@
 import { Database } from '@strapi/database';
-import { Strapi } from './Strapi';
+import { EntityService } from './services/entity-service';
+import { Strapi as StrapiClass } from './Strapi';
 
-type ID = number | string;
-
-interface Options<T> {
-  params: Params<T>;
-}
-
-interface Params<T> {
-  fields: (keyof T)[];
-}
-
-interface EntityService {
-  uploadFiles<T extends keyof AllTypes>(uid: T);
-  wrapOptions<T extends keyof AllTypes>(uid: T);
-
-  find<T extends keyof AllTypes>(uid: T): Promise<AllTypes[T][]>;
-  findPage<T extends keyof AllTypes>(uid: T): Promise<any>;
-  findWithRelationCounts<T extends keyof AllTypes>(uid: T): Promise<any>;
-  findOne<T extends keyof AllTypes>(
-    uid: T,
-    id: ID,
-    opts: Options<AllTypes[T]>
-  ): Promise<AllTypes[T]>;
-
-  count<T extends keyof AllTypes>(uid: T): Promise<any>;
-  create<T extends keyof AllTypes>(uid: T): Promise<any>;
-  update<T extends keyof AllTypes>(uid: T): Promise<any>;
-  delete<T extends keyof AllTypes>(uid: T): Promise<any>;
-}
-
-interface StrapiInterface extends Strapi {
+export * as factories from './factories';
+interface StrapiInterface extends StrapiClass {
   query: Database['query'];
   entityService: EntityService;
 }
 
+export type Strapi = StrapiInterface;
+
 declare global {
   interface AllTypes {}
 }
@@ -44,5 +19,9 @@ declare global {
     strapi: StrapiInterface;
   }
 
+  export type Strapi = StrapiInterface;
+
   const strapi: StrapiInterface;
 }
+
+export default function(opts): Strapi;

package/lib/index.js

@@ -1,3 +1,7 @@
 'use strict';
 
-module.exports = require('./Strapi');
+const Strapi = require('./Strapi');
+
+Strapi.factories = require('./factories');
+
+module.exports = Strapi;

package/lib/middlewares/body.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { defaultsDeep } = require('lodash/fp');
+const body = require('koa-body');
+
+const defaults = {
+  multipart: true,
+  patchKoa: true,
+};
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = config => {
+  const bodyConfig = defaultsDeep(defaults, config);
+
+  return async (ctx, next) => {
+    // TODO: find a better way later
+    if (ctx.url === '/graphql') {
+      return next();
+    }
+
+    try {
+      await body({ patchKoa: true, ...bodyConfig })(ctx, next);
+    } catch (e) {
+      if ((e || {}).message && e.message.includes('maxFileSize exceeded')) {
+        return ctx.payloadTooLarge('FileTooBig');
+      }
+
+      throw e;
+    }
+  };
+};

package/lib/middlewares/compression.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const compress = require('koa-compress');
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = config => compress(config);

package/lib/middlewares/cors.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { defaultsDeep } = require('lodash/fp');
+const cors = require('@koa/cors');
+
+const defaults = {
+  origin: '*',
+  maxAge: 31536000,
+  credentials: true,
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'],
+  headers: ['Content-Type', 'Authorization', 'Origin', 'Accept'],
+  keepHeadersOnError: false,
+};
+
+/**
+ * @type {import('./').MiddlewareFactory}
+ */
+module.exports = config => {
+  const {
+    origin,
+    expose,
+    maxAge,
+    credentials,
+    methods,
+    headers,
+    keepHeadersOnError,
+  } = defaultsDeep(defaults, config);
+
+  return cors({
+    async origin(ctx) {
+      let originList;
+
+      if (typeof origin === 'function') {
+        originList = await origin(ctx);
+      } else {
+        originList = origin;
+      }
+
+      const whitelist = Array.isArray(originList) ? originList : originList.split(/\s*,\s*/);
+
+      const requestOrigin = ctx.accept.headers.origin;
+      if (whitelist.includes('*')) {
+        return '*';
+      }
+
+      if (!whitelist.includes(requestOrigin)) {
+        return ctx.throw(`${requestOrigin} is not a valid origin`);
+      }
+      return requestOrigin;
+    },
+    exposeHeaders: expose,
+    maxAge,
+    credentials,
+    allowMethods: methods,
+    allowHeaders: headers,
+    keepHeadersOnError,
+  });
+};