@strapi/strapi 4.0.0-beta.0

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

@@ -0,0 +1,365 @@
+'use strict';
+
+const _ = require('lodash');
+const { has, prop, omit, toString } = require('lodash/fp');
+
+const { contentTypes: contentTypesUtils } = require('@strapi/utils');
+
+const omitComponentData = (contentType, data) => {
+  const { attributes } = contentType;
+  const componentAttributes = Object.keys(attributes).filter(attributeName =>
+    contentTypesUtils.isComponentAttribute(attributes[attributeName])
+  );
+
+  return omit(componentAttributes, data);
+};
+
+// NOTE: we could generalize the logic to allow CRUD of relation directly in the DB layer
+const createComponents = async (uid, data) => {
+  const { attributes } = strapi.getModel(uid);
+
+  const componentBody = {};
+
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+
+    if (!has(attributeName, data) || !contentTypesUtils.isComponentAttribute(attribute)) {
+      continue;
+    }
+
+    if (attribute.type === 'component') {
+      const { component: componentUID, repeatable = false } = attribute;
+
+      const componentValue = data[attributeName];
+
+      if (componentValue === null) {
+        continue;
+      }
+
+      if (repeatable === true) {
+        if (!Array.isArray(componentValue)) {
+          throw new Error('Expected an array to create repeatable component');
+        }
+
+        const components = await Promise.all(
+          componentValue.map(value => createComponent(componentUID, value))
+        );
+
+        // TODO: add order
+        componentBody[attributeName] = components.map(({ id }, idx) => {
+          return {
+            id,
+            __pivot: {
+              order: idx + 1,
+              field: attributeName,
+              component_type: componentUID,
+            },
+          };
+        });
+      } else {
+        const component = await createComponent(componentUID, componentValue);
+        componentBody[attributeName] = {
+          id: component.id,
+          __pivot: {
+            order: 1,
+            field: attributeName,
+            component_type: componentUID,
+          },
+        };
+      }
+
+      continue;
+    }
+
+    if (attribute.type === 'dynamiczone') {
+      const dynamiczoneValues = data[attributeName];
+
+      if (!Array.isArray(dynamiczoneValues)) {
+        throw new Error('Expected an array to create repeatable component');
+      }
+
+      componentBody[attributeName] = await Promise.all(
+        dynamiczoneValues.map(async (value, idx) => {
+          const { id } = await createComponent(value.__component, value);
+          return {
+            id,
+            __component: value.__component,
+            __pivot: {
+              order: idx + 1,
+              field: attributeName,
+            },
+          };
+        })
+      );
+
+      continue;
+    }
+  }
+
+  return componentBody;
+};
+
+/*
+  delete old components
+  create or update
+*/
+const updateComponents = async (uid, entityToUpdate, data) => {
+  const { attributes } = strapi.getModel(uid);
+
+  const componentBody = {};
+
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+
+    if (!has(attributeName, data)) {
+      continue;
+    }
+
+    if (attribute.type === 'component') {
+      const { component: componentUID, repeatable = false } = attribute;
+
+      const componentValue = data[attributeName];
+
+      await deleteOldComponents(uid, componentUID, entityToUpdate, attributeName, componentValue);
+
+      if (repeatable === true) {
+        if (!Array.isArray(componentValue)) {
+          throw new Error('Expected an array to create repeatable component');
+        }
+
+        const components = await Promise.all(
+          componentValue.map(value => updateOrCreateComponent(componentUID, value))
+        );
+
+        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 && {
+          id: component.id,
+          __pivot: {
+            order: 1,
+            field: attributeName,
+            component_type: componentUID,
+          },
+        };
+      }
+
+      continue;
+    }
+
+    if (attribute.type === 'dynamiczone') {
+      const dynamiczoneValues = data[attributeName];
+
+      await deleteOldDZComponents(uid, entityToUpdate, attributeName, dynamiczoneValues);
+
+      if (!Array.isArray(dynamiczoneValues)) {
+        throw new Error('Expected an array to create repeatable component');
+      }
+
+      componentBody[attributeName] = await Promise.all(
+        dynamiczoneValues.map(async (value, idx) => {
+          const { id } = await updateOrCreateComponent(value.__component, value);
+
+          return {
+            id,
+            __component: value.__component,
+            __pivot: {
+              order: idx + 1,
+              field: attributeName,
+            },
+          };
+        })
+      );
+
+      continue;
+    }
+  }
+
+  return componentBody;
+};
+
+const deleteOldComponents = async (
+  uid,
+  componentUID,
+  entityToUpdate,
+  attributeName,
+  componentValue
+) => {
+  const previousValue = await strapi.query(uid).load(entityToUpdate, attributeName);
+
+  const idsToKeep = _.castArray(componentValue)
+    .filter(has('id'))
+    .map(prop('id'))
+    .map(toString);
+
+  const allIds = _.castArray(previousValue)
+    .filter(has('id'))
+    .map(prop('id'))
+    .map(toString);
+
+  idsToKeep.forEach(id => {
+    if (!allIds.includes(id)) {
+      const err = new Error(
+        `Some of the provided components in ${attributeName} are not related to the entity`
+      );
+      err.status = 400;
+      throw err;
+    }
+  });
+
+  const idsToDelete = _.difference(allIds, idsToKeep);
+
+  if (idsToDelete.length > 0) {
+    for (const idToDelete of idsToDelete) {
+      await deleteComponent(componentUID, { id: idToDelete });
+    }
+  }
+};
+
+const deleteOldDZComponents = async (uid, entityToUpdate, attributeName, dynamiczoneValues) => {
+  const previousValue = await strapi.query(uid).load(entityToUpdate, attributeName);
+
+  const idsToKeep = _.castArray(dynamiczoneValues)
+    .filter(has('id'))
+    .map(({ id, __component }) => ({
+      id: toString(id),
+      __component,
+    }));
+
+  const allIds = _.castArray(previousValue)
+    .filter(has('id'))
+    .map(({ id, __component }) => ({
+      id: toString(id),
+      __component,
+    }));
+
+  idsToKeep.forEach(({ id, __component }) => {
+    if (!allIds.find(el => el.id === id && el.__component === __component)) {
+      const err = new Error(
+        `Some of the provided components in ${attributeName} are not related to the entity`
+      );
+      err.status = 400;
+      throw err;
+    }
+  });
+
+  const idsToDelete = allIds.reduce((acc, { id, __component }) => {
+    if (!idsToKeep.find(el => el.id === id && el.__component === __component)) {
+      acc.push({ id, __component });
+    }
+
+    return acc;
+  }, []);
+
+  if (idsToDelete.length > 0) {
+    for (const idToDelete of idsToDelete) {
+      const { id, __component } = idToDelete;
+      await deleteComponent(__component, { id });
+    }
+  }
+};
+
+const deleteComponents = async (uid, entityToDelete) => {
+  const { attributes } = strapi.getModel(uid);
+
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+
+    if (attribute.type === 'component') {
+      const { component: componentUID } = attribute;
+
+      const value = await strapi.query(uid).load(entityToDelete, attributeName);
+
+      if (!value) {
+        continue;
+      }
+
+      if (Array.isArray(value)) {
+        await Promise.all(value.map(subValue => deleteComponent(componentUID, subValue)));
+      } else {
+        await deleteComponent(componentUID, value);
+      }
+
+      continue;
+    }
+
+    if (attribute.type === 'dynamiczone') {
+      const value = await strapi.query(uid).load(entityToDelete, attributeName);
+
+      if (!value) {
+        continue;
+      }
+
+      if (Array.isArray(value)) {
+        await Promise.all(value.map(subValue => deleteComponent(subValue.__component, subValue)));
+      }
+
+      continue;
+    }
+  }
+};
+
+/***************************
+    Component queries
+***************************/
+
+// components can have nested compos so this must be recursive
+const createComponent = async (uid, data) => {
+  const model = strapi.getModel(uid);
+
+  const componentData = await createComponents(uid, data);
+
+  return strapi.query(uid).create({
+    data: Object.assign(omitComponentData(model, data), componentData),
+  });
+};
+
+// components can have nested compos so this must be recursive
+const updateComponent = async (uid, componentToUpdate, data) => {
+  const model = strapi.getModel(uid);
+
+  const componentData = await updateComponents(uid, componentToUpdate, data);
+
+  return strapi.query(uid).update({
+    where: {
+      id: componentToUpdate.id,
+    },
+    data: Object.assign(omitComponentData(model, data), componentData),
+  });
+};
+
+const updateOrCreateComponent = (componentUID, value) => {
+  if (value === null) {
+    return null;
+  }
+
+  // update
+  if (has('id', value)) {
+    // TODO: verify the compo is associated with the entity
+    return updateComponent(componentUID, { id: value.id }, value);
+  }
+
+  // create
+  return createComponent(componentUID, value);
+};
+
+const deleteComponent = async (uid, componentToDelete) => {
+  await deleteComponents(uid, componentToDelete);
+  await strapi.query(uid).delete({ where: { id: componentToDelete.id } });
+};
+
+module.exports = {
+  omitComponentData,
+  createComponents,
+  updateComponents,
+  deleteComponents,
+};

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;
+};
+
+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

@@ -0,0 +1,244 @@
+'use strict';
+
+const delegate = require('delegates');
+const { pipe } = require('lodash/fp');
+
+const {
+  sanitizeEntity,
+  webhook: webhookUtils,
+  contentTypes: contentTypesUtils,
+} = require('@strapi/utils');
+const uploadFiles = require('../utils/upload-files');
+
+const {
+  omitComponentData,
+  createComponents,
+  updateComponents,
+  deleteComponents,
+} = require('./components');
+const {
+  transformCommonParams,
+  transformPaginationParams,
+  transformParamsToQuery,
+  pickSelectionParams,
+} = require('./params');
+
+// TODO: those should be strapi events used by the webhooks not the other way arround
+const { ENTRY_CREATE, ENTRY_UPDATE, ENTRY_DELETE } = webhookUtils.webhookEvents;
+
+module.exports = ctx => {
+  const implementation = createDefaultImplementation(ctx);
+
+  const service = {
+    implementation,
+    decorate(decorator) {
+      if (typeof decorator !== 'function') {
+        throw new Error(`Decorator must be a function, received ${typeof decorator}`);
+      }
+
+      this.implementation = Object.assign({}, this.implementation, decorator(this.implementation));
+      return this;
+    },
+  };
+
+  const delegator = delegate(service, 'implementation');
+
+  // delegate every method in implementation
+  Object.keys(service.implementation).forEach(key => delegator.method(key));
+
+  return service;
+};
+
+/**
+ * @type {import('.').default}
+ */
+const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator }) => ({
+  uploadFiles,
+
+  async wrapParams(options = {}) {
+    return options;
+  },
+
+  emitEvent(uid, event, entity) {
+    const model = strapi.getModel(uid);
+
+    eventHub.emit(event, {
+      model: model.modelName,
+      entry: sanitizeEntity(entity, { model }),
+    });
+  },
+
+  async findMany(uid, opts) {
+    const { kind } = strapi.getModel(uid);
+
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findMany' });
+
+    const query = transformParamsToQuery(uid, wrappedParams);
+
+    if (kind === 'singleType') {
+      return db.query(uid).findOne(query);
+    }
+
+    return db.query(uid).findMany(query);
+  },
+
+  async findPage(uid, opts) {
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findPage' });
+
+    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 wrappedParams = await this.wrapParams(opts, { uid, action: 'findWithRelationCounts' });
+
+    const query = transformParamsToQuery(uid, wrappedParams);
+
+    const { results, pagination } = await db.query(uid).findPage(query);
+
+    return {
+      results,
+      pagination,
+    };
+  },
+
+  async findOne(uid, entityId, opts) {
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'findOne' });
+
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
+
+    return db.query(uid).findOne({ ...query, where: { id: entityId } });
+  },
+
+  async count(uid, opts) {
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'count' });
+
+    const query = transformParamsToQuery(uid, wrappedParams);
+
+    return db.query(uid).count(query);
+  },
+
+  async create(uid, opts) {
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'create' });
+    const { data, files } = wrappedParams;
+
+    const model = strapi.getModel(uid);
+
+    const isDraft = contentTypesUtils.isDraft(data, model);
+    const validData = await entityValidator.validateEntityCreation(model, data, { isDraft });
+
+    // select / populate
+    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),
+    });
+
+    // 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, wrappedParams);
+    }
+
+    this.emitEvent(uid, ENTRY_CREATE, entity);
+
+    return entity;
+  },
+
+  async update(uid, entityId, opts) {
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'update' });
+    const { data, files } = wrappedParams;
+
+    const model = strapi.getModel(uid);
+
+    const entityToUpdate = await db.query(uid).findOne({ where: { id: entityId } });
+
+    if (!entityToUpdate) {
+      return null;
+    }
+
+    const isDraft = contentTypesUtils.isDraft(entityToUpdate, model);
+
+    const validData = await entityValidator.validateEntityUpdate(model, data, {
+      isDraft,
+    });
+
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
+
+    // TODO: wrap in transaction
+    const componentData = await updateComponents(uid, entityToUpdate, validData);
+
+    let entity = await db.query(uid).update({
+      ...query,
+      where: { id: entityId },
+      data: Object.assign(omitComponentData(model, validData), componentData),
+    });
+
+    // 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, wrappedParams);
+    }
+
+    this.emitEvent(uid, ENTRY_UPDATE, entity);
+
+    return entity;
+  },
+
+  async delete(uid, entityId, opts) {
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'delete' });
+
+    // select / populate
+    const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
+
+    const entityToDelete = await db.query(uid).findOne({
+      ...query,
+      where: { id: entityId },
+    });
+
+    if (!entityToDelete) {
+      return null;
+    }
+
+    await deleteComponents(uid, entityToDelete);
+    await db.query(uid).delete({ where: { id: entityToDelete.id } });
+
+    this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
+
+    return entityToDelete;
+  },
+
+  // FIXME: used only for the CM to be removed
+  async deleteMany(uid, opts) {
+    const wrappedParams = await this.wrapParams(opts, { uid, action: 'delete' });
+
+    // select / populate
+    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 =
+      attribute.type === 'relation'
+        ? transformParamsToQuery(attribute.target, params)
+        : pipe(
+            transformCommonParams,
+            transformPaginationParams
+          )(params);
+
+    return db.query(uid).load(entity, field, loadParams);
+  },
+});