@strapi/strapi 4.0.0-next.6 → 4.0.0

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;

package/lib/services/entity-service/attributes/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const transforms = require('./transforms');
+
+const applyTransforms = (data, context) => {
+  const { contentType } = context;
+
+  const entries = Object.entries(data);
+
+  for (const [attributeName, value] of entries) {
+    const attribute = contentType.attributes[attributeName];
+
+    if (!attribute) {
+      continue;
+    }
+
+    const transform = transforms[attribute.type];
+
+    if (transform) {
+      const attributeContext = { ...context, attributeName, attribute };
+
+      data[attributeName] = transform(value, attributeContext);
+    }
+  }
+
+  return data;
+};
+
+module.exports = {
+  applyTransforms,
+};

package/lib/services/entity-service/attributes/transforms.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { getOr, toNumber, isString, isBuffer } = require('lodash/fp');
+const bcrypt = require('bcryptjs');
+
+const transforms = {
+  password(value, context) {
+    const { attribute } = context;
+
+    if (!isString(value) && !isBuffer(value)) {
+      return value;
+    }
+
+    const rounds = toNumber(getOr(10, 'encryption.rounds', attribute));
+
+    return bcrypt.hashSync(value, rounds);
+  },
+};
+
+module.exports = transforms;

package/lib/services/entity-service/components.js

@@ -1,9 +1,10 @@
 'use strict';
 
 const _ = require('lodash');
-const { has, prop, omit } = require('lodash/fp');
+const { has, prop, omit, toString } = require('lodash/fp');
 
 const { contentTypes: contentTypesUtils } = require('@strapi/utils');
+const { ApplicationError } = require('@strapi/utils').errors;
 
 const omitComponentData = (contentType, data) => {
   const { attributes } = contentType;
@@ -131,11 +132,26 @@ const updateComponents = async (uid, entityToUpdate, data) => {
           componentValue.map(value => updateOrCreateComponent(componentUID, value))
         );
 
-        // TODO: add order
-        componentBody[attributeName] = components.filter(_.negate(_.isNil)).map(({ id }) => id);
+        componentBody[attributeName] = components.filter(_.negate(_.isNil)).map(({ id }, idx) => {
+          return {
+            id,
+            __pivot: {
+              order: idx + 1,
+              field: attributeName,
+              component_type: componentUID,
+            },
+          };
+        });
       } else {
         const component = await updateOrCreateComponent(componentUID, componentValue);
-        componentBody[attributeName] = component && component.id;
+        componentBody[attributeName] = component && {
+          id: component.id,
+          __pivot: {
+            order: 1,
+            field: attributeName,
+            component_type: componentUID,
+          },
+        };
       }
 
       continue;
@@ -151,9 +167,17 @@ const updateComponents = async (uid, entityToUpdate, data) => {
       }
 
       componentBody[attributeName] = await Promise.all(
-        dynamiczoneValues.map(async value => {
+        dynamiczoneValues.map(async (value, idx) => {
           const { id } = await updateOrCreateComponent(value.__component, value);
-          return { id, __component: value.__component };
+
+          return {
+            id,
+            __component: value.__component,
+            __pivot: {
+              order: idx + 1,
+              field: attributeName,
+            },
+          };
         })
       );
 
@@ -175,19 +199,19 @@ const deleteOldComponents = async (
 
   const idsToKeep = _.castArray(componentValue)
     .filter(has('id'))
-    .map(prop('id'));
+    .map(prop('id'))
+    .map(toString);
 
   const allIds = _.castArray(previousValue)
     .filter(has('id'))
-    .map(prop('id'));
+    .map(prop('id'))
+    .map(toString);
 
   idsToKeep.forEach(id => {
     if (!allIds.includes(id)) {
-      const err = new Error(
+      throw new ApplicationError(
         `Some of the provided components in ${attributeName} are not related to the entity`
       );
-      err.status = 400;
-      throw err;
     }
   });
 
@@ -206,14 +230,14 @@ const deleteOldDZComponents = async (uid, entityToUpdate, attributeName, dynamic
   const idsToKeep = _.castArray(dynamiczoneValues)
     .filter(has('id'))
     .map(({ id, __component }) => ({
-      id,
+      id: toString(id),
       __component,
     }));
 
   const allIds = _.castArray(previousValue)
     .filter(has('id'))
     .map(({ id, __component }) => ({
-      id,
+      id: toString(id),
       __component,
     }));
 
@@ -293,7 +317,7 @@ const createComponent = async (uid, data) => {
 
   const componentData = await createComponents(uid, data);
 
-  return await strapi.query(uid).create({
+  return strapi.query(uid).create({
     data: Object.assign(omitComponentData(model, data), componentData),
   });
 };
@@ -304,7 +328,7 @@ const updateComponent = async (uid, componentToUpdate, data) => {
 
   const componentData = await updateComponents(uid, componentToUpdate, data);
 
-  return await strapi.query(uid).update({
+  return strapi.query(uid).update({
     where: {
       id: componentToUpdate.id,
     },

package/lib/services/entity-service/index.d.ts

@@ -0,0 +1,91 @@
+import { Database } from '@strapi/database';
+import { Strapi } from '../../';
+
+type ID = number | string;
+
+type EntityServiceAction =
+  | 'findMany'
+  | 'findPage'
+  | 'findWithRelationCounts'
+  | 'findOne'
+  | 'count'
+  | 'create'
+  | 'update'
+  | 'delete';
+
+type PaginationInfo = {
+  page: number;
+  pageSize: number;
+  pageCount: number;
+  total: number;
+};
+
+type Params<T> = {
+  fields?: (keyof T)[];
+  filters?: any;
+  _q?: string;
+  populate?: any;
+  sort?: any;
+  start?: number;
+  limit?: number;
+  page?: number;
+  pageSize?: number;
+  publicationState?: string;
+  data?: any;
+  files?: any;
+};
+
+export interface EntityService {
+  uploadFiles<K extends keyof AllTypes, T extends AllTypes[K]>(uid: K, entity, files);
+  wrapParams<K extends keyof AllTypes, T extends AllTypes[K]>(
+    params: Params<T>,
+    { uid: K, action: EntityServiceAction }
+  );
+
+  findMany<K extends keyof AllTypes, T extends AllTypes[K]>(
+    uid: K,
+    params: Params<T>
+  ): Promise<T[]>;
+  findPage<K extends keyof AllTypes, T extends AllTypes[K]>(
+    uid: K,
+    params: Params<T>
+  ): Promise<{
+    results: T[];
+    pagination: PaginationInfo;
+  }>;
+
+  findWithRelationCounts<K extends keyof AllTypes, T extends AllTypes[K]>(
+    uid: K,
+    params: Params<T>
+  ): Promise<{
+    results: T[];
+    pagination: PaginationInfo;
+  }>;
+
+  findOne<K extends keyof AllTypes, T extends AllTypes[K]>(
+    uid: K,
+    entityId: ID,
+    params: Params<T>
+  ): Promise<T>;
+
+  count<K extends keyof AllTypes, T extends AllTypes[K]>(uid: K, params: Params<T>): Promise<any>;
+  create<K extends keyof AllTypes, T extends AllTypes[K]>(uid: K, params: Params<T>): Promise<any>;
+  update<K extends keyof AllTypes, T extends AllTypes[K]>(
+    uid: K,
+    entityId: ID,
+    params: Params<T>
+  ): Promise<any>;
+  delete<K extends keyof AllTypes, T extends AllTypes[K]>(
+    uid: K,
+    entityId: ID,
+    params: Params<T>
+  ): Promise<any>;
+}
+
+export default function(opts: {
+  strapi: Strapi;
+  db: Database;
+  // TODO: define types
+  eventHub: any;
+  entityValidator: any;
+}): EntityService;

package/lib/services/entity-service/index.js

@@ -1,12 +1,18 @@
 'use strict';
 
+const _ = require('lodash');
 const delegate = require('delegates');
 const {
-  sanitizeEntity,
+  InvalidTimeError,
+  InvalidDateError,
+  InvalidDateTimeError,
+} = require('@strapi/database').errors;
+const {
   webhook: webhookUtils,
   contentTypes: contentTypesUtils,
-  relations: relationsUtils,
+  sanitize,
 } = require('@strapi/utils');
+const { ValidationError } = require('@strapi/utils').errors;
 const uploadFiles = require('../utils/upload-files');
 
 const {
@@ -16,12 +22,21 @@ const {
   deleteComponents,
 } = require('./components');
 const { transformParamsToQuery, pickSelectionParams } = require('./params');
-
-const { MANY_RELATIONS } = relationsUtils.constants;
+const { applyTransforms } = require('./attributes');
 
 // TODO: those should be strapi events used by the webhooks not the other way arround
 const { ENTRY_CREATE, ENTRY_UPDATE, ENTRY_DELETE } = webhookUtils.webhookEvents;
 
+const databaseErrorsToTransform = [InvalidTimeError, InvalidDateTimeError, InvalidDateError];
+
+const creationPipeline = (data, context) => {
+  return applyTransforms(data, context);
+};
+
+const updatePipeline = (data, context) => {
+  return applyTransforms(data, context);
+};
+
 module.exports = ctx => {
   const implementation = createDefaultImplementation(ctx);
 
@@ -42,31 +57,57 @@ module.exports = ctx => {
   // delegate every method in implementation
   Object.keys(service.implementation).forEach(key => delegator.method(key));
 
+  // wrap methods to handle Database Errors
+  service.decorate(oldService => {
+    const newService = _.mapValues(
+      oldService,
+      (method, methodName) =>
+        async function(...args) {
+          try {
+            return await oldService[methodName].call(this, ...args);
+          } catch (error) {
+            if (
+              databaseErrorsToTransform.some(errorToTransform => error instanceof errorToTransform)
+            ) {
+              throw new ValidationError(error.message);
+            }
+            throw error;
+          }
+        }
+    );
+
+    return newService;
+  });
+
   return service;
 };
 
+/**
+ * @type {import('.').default}
+ */
 const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator }) => ({
   uploadFiles,
 
-  async wrapOptions(options = {}) {
+  async wrapParams(options = {}) {
     return options;
   },
 
-  emitEvent(uid, event, entity) {
+  async emitEvent(uid, event, entity) {
     const model = strapi.getModel(uid);
+    const sanitizedEntity = await sanitize.sanitizers.defaultSanitizeOutput(model, entity);
 
     eventHub.emit(event, {
       model: model.modelName,
-      entry: sanitizeEntity(entity, { model }),
+      entry: sanitizedEntity,
     });
   },
 
-  async find(uid, opts) {
+  async findMany(uid, opts) {
     const { kind } = strapi.getModel(uid);
 
-    const { params } = await this.wrapOptions(opts, { uid, action: 'find' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findMany' });
 
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
     if (kind === 'singleType') {
       return db.query(uid).findOne(query);
@@ -76,41 +117,20 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
   },
 
   async findPage(uid, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'findPage' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findPage' });
 
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
     return db.query(uid).findPage(query);
   },
 
+  // TODO: streamline the logic based on the populate option
   async findWithRelationCounts(uid, opts) {
-    const model = strapi.getModel(uid);
-
-    const { params } = await this.wrapOptions(opts, { uid, action: 'findWithRelationCounts' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findWithRelationCounts' });
 
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
-    const { attributes } = model;
-
-    const populate = (query.populate || []).reduce((populate, attributeName) => {
-      const attribute = attributes[attributeName];
-
-      if (
-        MANY_RELATIONS.includes(attribute.relation) &&
-        contentTypesUtils.isVisibleAttribute(model, attributeName)
-      ) {
-        populate[attributeName] = { count: true };
-      } else {
-        populate[attributeName] = true;
-      }
-
-      return populate;
-    }, {});
-
-    const { results, pagination } = await db.query(uid).findPage({
-      ...query,
-      populate,
-    });
+    const { results, pagination } = await db.query(uid).findPage(query);
 
     return {
       results,
@@ -119,23 +139,24 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
   },
 
   async findOne(uid, entityId, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'findOne' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findOne' });
 
-    const query = transformParamsToQuery(uid, pickSelectionParams(params));
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
     return db.query(uid).findOne({ ...query, where: { id: entityId } });
   },
 
   async count(uid, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'count' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'count' });
 
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
     return db.query(uid).count(query);
   },
 
   async create(uid, opts) {
-    const { params, data, files } = await this.wrapOptions(opts, { uid, action: 'create' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'create' });
+    const { data, files } = wrappedParams;
 
     const model = strapi.getModel(uid);
 
@@ -143,30 +164,33 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     const validData = await entityValidator.validateEntityCreation(model, data, { isDraft });
 
     // select / populate
-    const query = transformParamsToQuery(uid, pickSelectionParams(params));
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
     // TODO: wrap into transaction
     const componentData = await createComponents(uid, validData);
 
     let entity = await db.query(uid).create({
       ...query,
-      data: Object.assign(omitComponentData(model, validData), componentData),
+      data: creationPipeline(Object.assign(omitComponentData(model, validData), componentData), {
+        contentType: model,
+      }),
     });
 
     // TODO: upload the files then set the links in the entity like with compo to avoid making too many queries
     // FIXME: upload in components
     if (files && Object.keys(files).length > 0) {
       await this.uploadFiles(uid, entity, files);
-      entity = await this.findOne(uid, entity.id, { params });
+      entity = await this.findOne(uid, entity.id, wrappedParams);
     }
 
-    this.emitEvent(uid, ENTRY_CREATE, entity);
+    await this.emitEvent(uid, ENTRY_CREATE, entity);
 
     return entity;
   },
 
   async update(uid, entityId, opts) {
-    const { params, data, files } = await this.wrapOptions(opts, { uid, action: 'update' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'update' });
+    const { data, files } = wrappedParams;
 
     const model = strapi.getModel(uid);
 
@@ -178,11 +202,16 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     const isDraft = contentTypesUtils.isDraft(entityToUpdate, model);
 
-    const validData = await entityValidator.validateEntityUpdate(model, data, {
-      isDraft,
-    });
+    const validData = await entityValidator.validateEntityUpdate(
+      model,
+      data,
+      {
+        isDraft,
+      },
+      entityToUpdate
+    );
 
-    const query = transformParamsToQuery(uid, pickSelectionParams(params));
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
     // TODO: wrap in transaction
     const componentData = await updateComponents(uid, entityToUpdate, validData);
@@ -190,26 +219,28 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     let entity = await db.query(uid).update({
       ...query,
       where: { id: entityId },
-      data: Object.assign(omitComponentData(model, validData), componentData),
+      data: updatePipeline(Object.assign(omitComponentData(model, validData), componentData), {
+        contentType: model,
+      }),
     });
 
     // TODO: upload the files then set the links in the entity like with compo to avoid making too many queries
     // FIXME: upload in components
     if (files && Object.keys(files).length > 0) {
       await this.uploadFiles(uid, entity, files);
-      entity = await this.findOne(uid, entity.id, { params });
+      entity = await this.findOne(uid, entity.id, wrappedParams);
     }
 
-    this.emitEvent(uid, ENTRY_UPDATE, entity);
+    await this.emitEvent(uid, ENTRY_UPDATE, entity);
 
     return entity;
   },
 
   async delete(uid, entityId, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'delete' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'delete' });
 
     // select / populate
-    const query = transformParamsToQuery(uid, pickSelectionParams(params));
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
     const entityToDelete = await db.query(uid).findOne({
       ...query,
@@ -223,17 +254,47 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     await deleteComponents(uid, entityToDelete);
     await db.query(uid).delete({ where: { id: entityToDelete.id } });
 
-    this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
+    await this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
 
     return entityToDelete;
   },
 
+  // FIXME: used only for the CM to be removed
   async deleteMany(uid, opts) {
-    const { params } = await this.wrapOptions(opts, { uid, action: 'delete' });
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'delete' });
 
     // select / populate
-    const query = transformParamsToQuery(uid, params);
+    const query = transformParamsToQuery(uid, wrappedParams);
 
     return db.query(uid).deleteMany(query);
   },
+
+  load(uid, entity, field, params = {}) {
+    const { attributes } = strapi.getModel(uid);
+
+    const attribute = attributes[field];
+
+    const loadParams = {};
+
+    switch (attribute.type) {
+      case 'relation': {
+        Object.assign(loadParams, transformParamsToQuery(attribute.target, params));
+        break;
+      }
+      case 'component': {
+        Object.assign(loadParams, transformParamsToQuery(attribute.component, params));
+        break;
+      }
+      case 'dynamiczone': {
+        Object.assign(loadParams, transformParamsToQuery(null, params));
+        break;
+      }
+      case 'media': {
+        Object.assign(loadParams, transformParamsToQuery('plugin::upload.file', params));
+        break;
+      }
+    }
+
+    return db.query(uid).load(entity, field, loadParams);
+  },
 });