@strapi/strapi 4.0.0-next.11 → 4.0.0-next.15

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/service/collection-type.js

@@ -28,19 +28,18 @@ const createCollectionTypeService = ({ model, strapi, utils }) => {
   const { sanitizeInput, getFetchParams } = utils;
 
   return {
-    async find(opts = {}) {
-      const params = getFetchParams(opts.params);
+    async find(params = {}) {
+      const fetchParams = 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 +53,30 @@ 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, getFetchParams(params));
     },
 
-    create({ params, data, files } = {}) {
+    create(params = {}) {
+      const { data } = params;
       const sanitizedData = sanitizeInput(data);
 
       if (hasDraftAndPublish(model)) {
         setPublishedAt(sanitizedData);
       }
 
-      return strapi.entityService.create(uid, { params, data: sanitizedData, files });
+      return strapi.entityService.create(uid, { ...params, data: sanitizedData });
     },
 
-    update(entityId, { params, data, files } = {}) {
+    update(entityId, params = {}) {
+      const { data } = params;
       const sanitizedData = sanitizeInput(data);
 
-      return strapi.entityService.update(uid, entityId, { params, data: sanitizedData, files });
+      return strapi.entityService.update(uid, entityId, { ...params, data: sanitizedData });
     },
 
-    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/single-type.js

@@ -13,9 +13,8 @@ const createSingleTypeService = ({ model, strapi, utils }) => {
      *
      * @return {Promise}
      */
-    find({ params } = {}) {
-      const normalizedParams = getFetchParams(params);
-      return strapi.entityService.find(uid, { params: normalizedParams });
+    find(params = {}) {
+      return strapi.entityService.findMany(uid, getFetchParams(params));
     },
 
     /**
@@ -23,9 +22,10 @@ const createSingleTypeService = ({ model, strapi, utils }) => {
      *
      * @return {Promise}
      */
-    async createOrUpdate({ params, data, files } = {}) {
-      const entity = await this.find({ params });
+    async createOrUpdate(params = {}) {
+      const entity = await this.find(params);
 
+      const { data } = params;
       const sanitizedData = sanitizeInput(data);
 
       if (!entity) {
@@ -34,14 +34,10 @@ const createSingleTypeService = ({ model, strapi, utils }) => {
           throw strapi.errors.badRequest('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: sanitizedData });
       }
+
+      return strapi.entityService.update(uid, entity.id, { ...params, data: sanitizedData });
     },
 
     /**
@@ -49,8 +45,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/index.d.ts

@@ -1,40 +1,14 @@
 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 {
+interface StrapiInterface extends StrapiClass {
   query: Database['query'];
   entityService: EntityService;
 }
 
+export type Strapi = StrapiInterface;
+
 declare global {
   interface AllTypes {}
 }
@@ -44,5 +18,9 @@ declare global {
     strapi: StrapiInterface;
   }
 
+  export type Strapi = StrapiInterface;
+
   const strapi: StrapiInterface;
 }
+
+export default function(opts): Strapi;

package/lib/middlewares/cors/index.js

@@ -32,7 +32,7 @@ module.exports = strapi => {
 
       strapi.server.use(
         cors({
-          origin: async function(ctx) {
+          async origin(ctx) {
             let originList;
 
             if (typeof origin === 'function') {

package/lib/middlewares/{boom → error}/defaults.json

@@ -1,5 +1,5 @@
 {
-  "boom": {
+  "error": {
     "enabled": true
   }
 }

package/lib/middlewares/{boom → error}/index.js

@@ -6,7 +6,7 @@
 
 // Public node modules.
 const _ = require('lodash');
-const Boom = require('boom');
+const Boom = require('@hapi/boom');
 const delegate = require('delegates');
 
 const boomMethods = [

package/lib/middlewares/favicon/index.js

@@ -19,11 +19,10 @@ module.exports = strapi => {
      */
 
     initialize() {
-      const { dir } = strapi;
       const { maxAge, path: faviconPath } = strapi.config.middleware.settings.favicon;
 
       strapi.server.use(
-        favicon(resolve(dir, faviconPath), {
+        favicon(resolve(strapi.dirs.root, faviconPath), {
           maxAge,
         })
       );

package/lib/middlewares/index.js

@@ -7,7 +7,7 @@ const requiredMiddlewares = [
   'responses',
   'router',
   'logger',
-  'boom',
+  'error',
   'cors',
   'cron',
   'xframe',

package/lib/middlewares/public/index.js

@@ -25,7 +25,7 @@ module.exports = strapi => {
 
     async initialize() {
       const { defaultIndex, maxAge, path: publicPath } = strapi.config.middleware.settings.public;
-      const staticDir = path.resolve(strapi.dir, publicPath || strapi.config.paths.static);
+      const staticDir = path.resolve(strapi.dirs.root, publicPath || strapi.config.paths.static);
 
       if (defaultIndex === true) {
         const index = fs.readFileSync(path.join(__dirname, 'index.html'), 'utf8');
@@ -98,7 +98,7 @@ module.exports = strapi => {
 
       if (!strapi.config.serveAdminPanel) return;
 
-      const buildDir = path.resolve(strapi.dir, 'build');
+      const buildDir = path.resolve(strapi.dirs.root, 'build');
       const serveAdmin = async (ctx, next) => {
         await next();
 

package/lib/middlewares/responses/index.js

@@ -8,7 +8,8 @@ module.exports = strapi => {
       strapi.server.use(async (ctx, next) => {
         await next();
 
-        const responseFn = strapi.config.get(['functions', 'responses', ctx.status]);
+        const status = ctx.status;
+        const responseFn = strapi.config.get(`middleware.settings.responses.handlers.${status}`);
         if (_.isFunction(responseFn)) {
           await responseFn(ctx);
         }

package/lib/middlewares/router/index.js

@@ -9,9 +9,11 @@ const createRouteScopeGenerator = namespace => route => {
   if (typeof route.handler === 'string') {
     const [controller, action] = route.handler.split('.');
 
-    _.defaultsDeep(route.config, {
-      auth: {
-        scope: `${prefix}${controller}.${toLower(action)}`,
+    _.defaultsDeep(route, {
+      config: {
+        auth: {
+          scope: `${prefix}${controller}.${toLower(action)}`,
+        },
       },
     });
   }

package/lib/migrations/draft-publish.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const { hasDraftAndPublish } = require('@strapi/utils').contentTypes;
+
+const enableDraftAndPublish = async ({ oldContentTypes, contentTypes }) => {
+  if (!oldContentTypes) {
+    return;
+  }
+  // run the after content types migrations
+
+  for (const uid in contentTypes) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes[uid];
+
+    // if d&p was enabled set publishedAt to eq createdAt
+    if (!hasDraftAndPublish(oldContentType) && hasDraftAndPublish(contentType)) {
+      const qb = strapi.db.queryBuilder(uid);
+      await qb
+        .update({ publishedAt: qb.ref('createdAt') })
+        .where({ publishedAt: null })
+        .execute();
+    }
+  }
+};
+
+const disableDraftAndPublish = async ({ oldContentTypes, contentTypes }) => {
+  if (!oldContentTypes) {
+    return;
+  }
+
+  for (const uid in contentTypes) {
+    if (!oldContentTypes[uid]) {
+      continue;
+    }
+
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes[uid];
+
+    // if d&p was disabled remove unpublish content before sync
+    if (hasDraftAndPublish(oldContentType) && !hasDraftAndPublish(contentType)) {
+      await strapi.db
+        .queryBuilder(uid)
+        .delete()
+        .where({ publishedAt: null })
+        .execute();
+    }
+  }
+};
+
+module.exports = {
+  enable: enableDraftAndPublish,
+  disable: disableDraftAndPublish,
+};

package/lib/services/auth/index.js

@@ -69,7 +69,7 @@ const createAuthentication = () => {
         }
       }
 
-      return ctx.unauthorized('Missing credentials');
+      return ctx.unauthorized('Missing or invalid credentials');
     },
     async verify(auth, config = {}) {
       if (config === false) {
@@ -81,7 +81,7 @@ const createAuthentication = () => {
       }
 
       if (typeof auth.strategy.verify === 'function') {
-        return await auth.strategy.verify(auth, config);
+        return auth.strategy.verify(auth, config);
       }
 
       return;

package/lib/services/core-store.js

@@ -22,21 +22,37 @@ const coreStoreModel = {
   },
 };
 
-const createCoreStore = ({ environment: defaultEnv, db }) => {
-  return (source = {}) => {
-    async function get(params = {}) {
-      const { key, environment = defaultEnv, type = 'core', name = '', tag = '' } = Object.assign(
-        {},
-        source,
-        params
-      );
+const createCoreStore = ({ db }) => {
+  const mergeParams = (defaultParams, params) => {
+    return {
+      ...defaultParams,
+      ...params,
+    };
+  };
+
+  const store = function(defaultParams = {}) {
+    return {
+      get: params => store.get(mergeParams(defaultParams, params)),
+      set: params => store.set(mergeParams(defaultParams, params)),
+      delete: params => store.delete(mergeParams(defaultParams, params)),
+    };
+  };
+
+  Object.assign(store, {
+    /**
+     * Get value from the core store
+     * @param {Object} params
+     * @returns {*}
+     */
+    async get(params = {}) {
+      const { key, type = 'core', environment, name, tag } = params;
 
       const prefix = `${type}${name ? `_${name}` : ''}`;
 
       const where = {
         key: `${prefix}_${key}`,
-        environment,
-        tag,
+        environment: environment || null,
+        tag: tag || null,
       };
 
       const data = await db.query('strapi::core-store').findOne({ where });
@@ -57,71 +73,70 @@ const createCoreStore = ({ environment: defaultEnv, db }) => {
           return new Date(data.value);
         }
       } else if (data.type === 'number') {
-        return parseFloat(data.value);
+        return Number(data.value);
       } else {
         return null;
       }
-    }
+    },
 
-    async function set(params = {}) {
-      const { key, value, environment = defaultEnv, type, name, tag = '' } = Object.assign(
-        {},
-        source,
-        params
-      );
+    /**
+     * Set value in the core store
+     * @param {Object} params
+     * @returns {*}
+     */
+    async set(params = {}) {
+      const { key, value, type, environment, name, tag } = params;
 
       const prefix = `${type}${name ? `_${name}` : ''}`;
 
       const where = {
         key: `${prefix}_${key}`,
-        environment,
-        tag,
+        environment: environment || null,
+        tag: tag || null,
       };
 
       const data = await db.query('strapi::core-store').findOne({ where });
 
       if (data) {
-        Object.assign(data, {
-          value: JSON.stringify(value) || value.toString(),
-          type: (typeof value).toString(),
+        return db.query('strapi::core-store').update({
+          where: { id: data.id },
+          data: {
+            value: JSON.stringify(value) || value.toString(),
+            type: typeof value,
+          },
         });
+      }
 
-        await db.query('strapi::core-store').update({ where: { id: data.id }, data });
-      } else {
-        const data = Object.assign({}, where, {
+      return db.query('strapi::core-store').create({
+        data: {
+          ...where,
           value: JSON.stringify(value) || value.toString(),
-          type: (typeof value).toString(),
-          tag,
-        });
-
-        await db.query('strapi::core-store').create({ data });
-      }
-    }
+          type: typeof value,
+        },
+      });
+    },
 
-    async function deleteFn(params = {}) {
-      const { key, environment = defaultEnv, type, name, tag = '' } = Object.assign(
-        {},
-        source,
-        params
-      );
+    /**
+     * Deletes a value from the core store
+     * @param {Object} params
+     * @returns {*}
+     */
+    async delete(params = {}) {
+      const { key, environment, type, name, tag } = params;
 
       const prefix = `${type}${name ? `_${name}` : ''}`;
 
       const where = {
         key: `${prefix}_${key}`,
-        environment,
-        tag,
+        environment: environment || null,
+        tag: tag || null,
       };
 
-      await db.query('strapi::core-store').delete({ where });
-    }
+      return db.query('strapi::core-store').delete({ where });
+    },
+  });
 
-    return {
-      get,
-      set,
-      delete: deleteFn,
-    };
-  };
+  return store;
 };
 
 module.exports = {

package/lib/services/cron.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { Job } = require('node-schedule');
+const { isFunction } = require('lodash/fp');
+
+const createCronService = () => {
+  let jobsSpecs = [];
+
+  return {
+    add(tasks = {}) {
+      for (const taskExpression in tasks) {
+        const taskValue = tasks[taskExpression];
+
+        let fn;
+        let options;
+        if (isFunction(taskValue)) {
+          fn = taskValue.bind(tasks);
+          options = taskExpression;
+        } else if (isFunction(taskValue.task)) {
+          fn = taskValue.task.bind(taskValue);
+          options = taskValue.options;
+        } else {
+          throw new Error(
+            `Could not schedule a cron job for "${taskExpression}": no function found.`
+          );
+        }
+
+        const fnWithStrapi = (...args) => fn({ strapi }, ...args);
+
+        const job = new Job(null, fnWithStrapi);
+        jobsSpecs.push({ job, options });
+      }
+      return this;
+    },
+    start() {
+      if (!strapi.config.get('server.cron.enabled')) {
+        return;
+      }
+      jobsSpecs.forEach(({ job, options }) => job.schedule(options));
+      return this;
+    },
+    stop() {
+      jobsSpecs.forEach(({ job }) => job.cancel());
+      return this;
+    },
+    destroy() {
+      this.stop();
+      jobsSpecs = [];
+      return this;
+    },
+  };
+};
+
+module.exports = createCronService;