@strapi/strapi 4.14.0-beta.0 → 4.14.0

package/lib/services/entity-service/types/params/sort.d.ts

@@ -1,106 +0,0 @@
-import type { Attribute, Common, Utils } from '@strapi/strapi';
-
-export module OrderKind {
-  export type Asc = 'asc';
-  export type Desc = 'desc';
-
-  export type Any = Asc | Desc;
-}
-
-/**
- * Single non-populatable attribute representation
- *
- * @example
- * type A = 'title'; // ✅
- * type B = 'description'; // ✅
- * type C = 'title:asc'; // ❌
- * type D = 'title,description'; // ❌
- */
-type SingleAttribute<TSchemaUID extends Common.UID.Schema> =
-  | 'id'
-  | Utils.Guard.Never<string & Attribute.GetNonPopulatableKeys<TSchemaUID>, string>;
-
-/**
- * Ordered single non-populatable attribute representation
- *
- * @example
- * type A = 'title:asc'; // ✅
- * type B = 'description:desc'; // ✅
- * type C = 'title'; // ❌
- * type D = 'title,description'; // ❌
- */
-type OrderedSingleAttribute<TSchemaUID extends Common.UID.Schema> =
-  `${SingleAttribute<TSchemaUID>}:${OrderKind.Any}`;
-
-/**
- * Union of all possible string representation for a sort
- *
- * @example
- * type A = 'title:asc'; // ✅
- * type B = 'description:desc'; // ✅
- * type C = 'title'; // ✅
- * type D = 'title,description:asc'; // ✅
- * type E = [42]; // ❌
- * type F = { title: 'asc' }; // ❌
- */
-export type StringNotation<TSchemaUID extends Common.UID.Schema> =
-  | SingleAttribute<TSchemaUID>
-  | OrderedSingleAttribute<TSchemaUID>
-  // TODO: Loose type checking to avoid circular dependencies & infinite recursion
-  | `${string},${string}`;
-
-/**
- * Array notation for a sort
- *
- * @example
- * type A = ['title:asc', 'description']; // ✅
- * type B = ['title']; // ✅
- * type C = ['count', 'title,description:asc']; // ✅
- * type D = { title: 'asc' }; // ❌
- * type E = [42]; // ❌
- * type F = 'title'; // ❌
- */
-export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Any<TSchemaUID>[];
-
-/**
- * Object notation for a sort
- *
- * @example
- * type A = { title: 'asc' }; // ✅
- * type B = { title: 'asc', description: 'desc' }; // ✅
- * type C = { title: 'asc', author: { name: 'asc' } }; // ✅
- * type D = { author: { email: 'asc', role: { name: 'desc' } } }; // ✅
- * type E = ['title']; // ❌
- * type F = 'title'; // ❌
- */
-export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = {
-  // First level sort
-  [key in SingleAttribute<TSchemaUID>]?: OrderKind.Any;
-} & {
-  // Deep sort, only add populatable keys that have a
-  // target (remove dynamic zones and other polymorphic links)
-  [key in Attribute.GetKeysWithTarget<TSchemaUID>]?: ObjectNotation<
-    Attribute.GetTarget<TSchemaUID, key>
-  >;
-};
-
-/**
- * Represents any notation for a sort (string, array, object)
- *
- * @example
- * type A = 'title:asc'; // ✅
- * type B = 'description:desc'; // ✅
- * type C = 'title'; // ✅
- * type D = 'title,description:asc'; // ✅
- * type E = ['title:asc', 'description']; // ✅
- * type F = ['title']; // ✅
- * type G = ['count', 'title,description:asc']; // ✅
- * type H = { title: 'asc' }; // ✅
- * type I = { title: 'asc', description: 'desc' }; // ✅
- * type J = { title: 'asc', author: { name: 'asc' } }; // ✅
- * type K = { author: { email: 'asc', role: { name: 'desc' } } }; // ✅
- */
-export type Any<TSchemaUID extends Common.UID.Schema> =
-  | StringNotation<TSchemaUID>
-  | ArrayNotation<TSchemaUID>
-  | ObjectNotation<TSchemaUID>;

package/lib/services/entity-service/types/plugin.d.ts

@@ -1,11 +0,0 @@
-import type { Common, Plugin, Utils, Shared } from '@strapi/strapi';
-
-export type GetPluginParams<TSchemaUID extends Common.UID.Schema> = Utils.Guard.OfTypes<
-  [never, undefined],
-  Utils.Object.Values<{
-    [TPluginName in keyof Shared.EntityServicePluginParams]: Shared.EntityServicePluginParams[TPluginName] extends infer TParam
-      ? Utils.Expression.If<Plugin.IsEnabled<TPluginName, TSchemaUID>, TParam>
-      : never;
-  }>,
-  unknown
->;

package/lib/services/entity-service/types/result.d.ts

@@ -1,205 +0,0 @@
-import type { Attribute, Common, EntityService, Utils } from '@strapi/strapi';
-
-type Pagination = { page: number; pageSize: number; pageCount: number; total: number };
-
-type AnyEntity = { id: EntityService.Params.Attribute.ID } & { [key: string]: any };
-
-export type Result<
-  TSchemaUID extends Common.UID.Schema,
-  TParams extends EntityService.Params.Pick<TSchemaUID, 'fields' | 'populate'> = never
-> = Utils.Expression.If<
-  Common.AreSchemaRegistriesExtended,
-  GetValues<
-    TSchemaUID,
-    Utils.Guard.Never<
-      ExtractFields<TSchemaUID, TParams['fields']>,
-      Attribute.GetNonPopulatableKeys<TSchemaUID>
-    >,
-    ExtractPopulate<TSchemaUID, TParams['populate']>
-  >,
-  AnyEntity
->;
-
-export type Entity<
-  TSchemaUID extends Common.UID.Schema,
-  TParams extends EntityService.Params.Pick<TSchemaUID, 'fields' | 'populate'> = never
-> = Utils.Expression.If<
-  Common.AreSchemaRegistriesExtended,
-  GetValues<
-    TSchemaUID,
-    Utils.Guard.Never<
-      ExtractFields<TSchemaUID, TParams['fields']>,
-      Attribute.GetNonPopulatableKeys<TSchemaUID>
-    >,
-    Utils.Guard.Never<
-      ExtractPopulate<TSchemaUID, TParams['populate']>,
-      Attribute.GetPopulatableKeys<TSchemaUID>
-    >
-  >,
-  AnyEntity
->;
-
-export type PartialEntity<
-  TSchemaUID extends Common.UID.Schema,
-  TParams extends EntityService.Params.Pick<TSchemaUID, 'fields' | 'populate'> = never
-> = Partial<Entity<TSchemaUID, TParams>>;
-
-export type PaginatedResult<
-  TSchemaUID extends Common.UID.Schema,
-  TParams extends EntityService.Params.Pick<TSchemaUID, 'fields' | 'populate'> = never
-> = {
-  results: Entity<TSchemaUID, TParams>[];
-  pagination: Pagination;
-};
-
-/**
- * Attribute.GetValues override with extended values
- *
- * TODO: Make it recursive for populatable fields
- */
-export type GetValues<
-  TSchemaUID extends Common.UID.Schema,
-  TFields extends Attribute.GetKeys<TSchemaUID>,
-  TPopulate extends Attribute.GetKeys<TSchemaUID>
-> = Utils.Expression.If<
-  Common.AreSchemaRegistriesExtended,
-  Utils.Guard.Never<TFields | TPopulate, Attribute.GetKeys<TSchemaUID>> extends infer TKeys
-    ? Attribute.GetValues<TSchemaUID, TKeys>
-    : never,
-  AnyEntity
->;
-
-type ExtractFields<
-  TSchemaUID extends Common.UID.Schema,
-  TFields extends EntityService.Params.Fields.Any<TSchemaUID>
-> = Utils.Expression.MatchFirst<
-  [
-    // No fields provided
-    [
-      Utils.Expression.Or<
-        Utils.Expression.StrictEqual<TFields, EntityService.Params.Fields.Any<TSchemaUID>>,
-        Utils.Expression.IsNever<TFields>
-      >,
-      never
-    ],
-    // string
-    [
-      Utils.Expression.Extends<TFields, EntityService.Params.Fields.StringNotation<TSchemaUID>>,
-      ParseStringFields<
-        TSchemaUID,
-        Utils.Cast<TFields, EntityService.Params.Fields.StringNotation<TSchemaUID>>
-      >
-    ],
-    // string array
-    [
-      Utils.Expression.Extends<TFields, EntityService.Params.Fields.ArrayNotation<TSchemaUID>>,
-      ParseStringFields<
-        TSchemaUID,
-        Utils.Cast<
-          Utils.Array.Values<
-            Utils.Cast<TFields, EntityService.Params.Fields.ArrayNotation<TSchemaUID>>
-          >,
-          EntityService.Params.Fields.StringNotation<TSchemaUID>
-        >
-      >
-    ]
-  ]
->;
-
-type ParseStringFields<
-  TSchemaUID extends Common.UID.Schema,
-  TFields extends EntityService.Params.Fields.StringNotation<TSchemaUID>
-> = Utils.Expression.MatchFirst<
-  [
-    [
-      Utils.Expression.StrictEqual<TFields, EntityService.Params.Fields.WildcardNotation>,
-      Attribute.GetNonPopulatableKeys<TSchemaUID>
-    ],
-    [
-      Utils.Expression.Extends<TFields, EntityService.Params.Fields.SingleAttribute<TSchemaUID>>,
-      TFields
-    ],
-    [
-      Utils.Expression.Extends<TFields, `${string},${string}`>,
-      Utils.Array.Values<Utils.String.Split<Utils.Cast<TFields, string>, ','>>
-    ]
-  ]
->;
-
-type ExtractPopulate<
-  TSchemaUID extends Common.UID.Schema,
-  TPopulate extends EntityService.Params.Populate.Any<TSchemaUID>
-> = Utils.Expression.MatchFirst<
-  [
-    // No populate provided
-    [
-      Utils.Expression.Or<
-        Utils.Expression.StrictEqual<TPopulate, EntityService.Params.Populate.Any<TSchemaUID>>,
-        Utils.Expression.IsNever<TPopulate>
-      >,
-      never
-    ],
-    // string notation
-    [
-      Utils.Expression.Extends<TPopulate, EntityService.Params.Populate.StringNotation<TSchemaUID>>,
-      ParseStringPopulate<
-        TSchemaUID,
-        Utils.Cast<TPopulate, EntityService.Params.Populate.StringNotation<TSchemaUID>>
-      >
-    ],
-    // Array notation
-    [
-      Utils.Expression.Extends<TPopulate, EntityService.Params.Populate.ArrayNotation<TSchemaUID>>,
-      ParseStringPopulate<
-        TSchemaUID,
-        Utils.Cast<
-          Utils.Array.Values<
-            Utils.Cast<TPopulate, EntityService.Params.Populate.ArrayNotation<TSchemaUID>>
-          >,
-          EntityService.Params.Populate.StringNotation<TSchemaUID>
-        >
-      >
-    ],
-    // object notation
-    [
-      Utils.Expression.Extends<TPopulate, EntityService.Params.Populate.ObjectNotation<TSchemaUID>>,
-      ParseStringPopulate<
-        TSchemaUID,
-        // TODO: Handle relations set to false in object notation
-        Utils.Cast<keyof TPopulate, EntityService.Params.Populate.StringNotation<TSchemaUID>>
-      >
-    ]
-  ]
->;
-
-type ParsePopulateDotNotation<
-  TSchemaUID extends Common.UID.Schema,
-  TPopulate extends EntityService.Params.Populate.StringNotation<TSchemaUID>
-> = Utils.String.Split<Utils.Cast<TPopulate, string>, '.'>[0];
-
-type ParseStringPopulate<
-  TSchemaUID extends Common.UID.Schema,
-  TPopulate extends EntityService.Params.Populate.StringNotation<TSchemaUID>
-> = Utils.Expression.MatchFirst<
-  [
-    [
-      Utils.Expression.StrictEqual<EntityService.Params.Populate.WildcardNotation, TPopulate>,
-      Attribute.GetPopulatableKeys<TSchemaUID>
-    ],
-    [
-      Utils.Expression.Extends<TPopulate, `${string},${string}`>,
-      ParsePopulateDotNotation<
-        TSchemaUID,
-        Utils.Cast<
-          Utils.Array.Values<Utils.String.Split<Utils.Cast<TPopulate, string>, ','>>,
-          EntityService.Params.Populate.StringNotation<TSchemaUID>
-        >
-      >
-    ],
-    [
-      Utils.Expression.Extends<TPopulate, `${string}.${string}`>,
-      ParsePopulateDotNotation<TSchemaUID, TPopulate>
-    ]
-  ],
-  TPopulate
->;

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

@@ -1,382 +0,0 @@
-/**
- * Entity validator
- * Module that will validate input data for entity creation or edition
- */
-
-'use strict';
-
-const { uniqBy, castArray, isNil, isArray, mergeWith } = require('lodash');
-const { has, assoc, prop, isObject, isEmpty } = require('lodash/fp');
-const strapiUtils = require('@strapi/utils');
-const validators = require('./validators');
-
-const { yup, validateYupSchema } = strapiUtils;
-const { isMediaAttribute, isScalarAttribute, getWritableAttributes } = strapiUtils.contentTypes;
-const { ValidationError } = strapiUtils.errors;
-
-const addMinMax = (validator, { attr, updatedAttribute }) => {
-  let nextValidator = validator;
-
-  if (
-    Number.isInteger(attr.min) &&
-    (attr.required || (Array.isArray(updatedAttribute.value) && updatedAttribute.value.length > 0))
-  ) {
-    nextValidator = nextValidator.min(attr.min);
-  }
-  if (Number.isInteger(attr.max)) {
-    nextValidator = nextValidator.max(attr.max);
-  }
-  return nextValidator;
-};
-
-const addRequiredValidation = (createOrUpdate) => {
-  return (validator, { attr: { required } }) => {
-    let nextValidator = validator;
-    if (required) {
-      if (createOrUpdate === 'creation') {
-        nextValidator = nextValidator.notNil();
-      } else if (createOrUpdate === 'update') {
-        nextValidator = nextValidator.notNull();
-      }
-    } else {
-      nextValidator = nextValidator.nullable();
-    }
-    return nextValidator;
-  };
-};
-
-const addDefault = (createOrUpdate) => {
-  return (validator, { attr }) => {
-    let nextValidator = validator;
-
-    if (createOrUpdate === 'creation') {
-      if (
-        ((attr.type === 'component' && attr.repeatable) || attr.type === 'dynamiczone') &&
-        !attr.required
-      ) {
-        nextValidator = nextValidator.default([]);
-      } else {
-        nextValidator = nextValidator.default(attr.default);
-      }
-    } else {
-      nextValidator = nextValidator.default(undefined);
-    }
-
-    return nextValidator;
-  };
-};
-
-const preventCast = (validator) => validator.transform((val, originalVal) => originalVal);
-
-const createComponentValidator =
-  (createOrUpdate) =>
-  ({ attr, updatedAttribute }, { isDraft }) => {
-    let validator;
-
-    const model = strapi.getModel(attr.component);
-    if (!model) {
-      throw new Error('Validation failed: Model not found');
-    }
-
-    if (prop('repeatable', attr) === true) {
-      validator = yup
-        .array()
-        .of(
-          yup.lazy((item) =>
-            createModelValidator(createOrUpdate)({ model, data: item }, { isDraft }).notNull()
-          )
-        );
-      validator = addRequiredValidation(createOrUpdate)(validator, { attr: { required: true } });
-      validator = addMinMax(validator, { attr, updatedAttribute });
-    } else {
-      validator = createModelValidator(createOrUpdate)({ model, updatedAttribute }, { isDraft });
-      validator = addRequiredValidation(createOrUpdate)(validator, {
-        attr: { required: !isDraft && attr.required },
-      });
-    }
-
-    return validator;
-  };
-
-const createDzValidator =
-  (createOrUpdate) =>
-  ({ attr, updatedAttribute }, { isDraft }) => {
-    let validator;
-
-    validator = yup.array().of(
-      yup.lazy((item) => {
-        const model = strapi.getModel(prop('__component', item));
-        const schema = yup
-          .object()
-          .shape({
-            __component: yup.string().required().oneOf(Object.keys(strapi.components)),
-          })
-          .notNull();
-
-        return model
-          ? schema.concat(createModelValidator(createOrUpdate)({ model, data: item }, { isDraft }))
-          : schema;
-      })
-    );
-    validator = addRequiredValidation(createOrUpdate)(validator, { attr: { required: true } });
-    validator = addMinMax(validator, { attr, updatedAttribute });
-
-    return validator;
-  };
-
-const createRelationValidator =
-  (createOrUpdate) =>
-  ({ attr, updatedAttribute }, { isDraft }) => {
-    let validator;
-
-    if (Array.isArray(updatedAttribute.value)) {
-      validator = yup.array().of(yup.mixed());
-    } else {
-      validator = yup.mixed();
-    }
-
-    validator = addRequiredValidation(createOrUpdate)(validator, {
-      attr: { required: !isDraft && attr.required },
-    });
-
-    return validator;
-  };
-
-const createScalarAttributeValidator = (createOrUpdate) => (metas, options) => {
-  let validator;
-
-  if (has(metas.attr.type, validators)) {
-    validator = validators[metas.attr.type](metas, options);
-  } else {
-    // No validators specified - fall back to mixed
-    validator = yup.mixed();
-  }
-
-  validator = addRequiredValidation(createOrUpdate)(validator, {
-    attr: { required: !options.isDraft && metas.attr.required },
-  });
-
-  return validator;
-};
-
-const createAttributeValidator = (createOrUpdate) => (metas, options) => {
-  let validator;
-
-  if (isMediaAttribute(metas.attr)) {
-    validator = yup.mixed();
-  } else if (isScalarAttribute(metas.attr)) {
-    validator = createScalarAttributeValidator(createOrUpdate)(metas, options);
-  } else {
-    if (metas.attr.type === 'component') {
-      validator = createComponentValidator(createOrUpdate)(metas, options);
-    } else if (metas.attr.type === 'dynamiczone') {
-      validator = createDzValidator(createOrUpdate)(metas, options);
-    } else {
-      validator = createRelationValidator(createOrUpdate)(metas, options);
-    }
-
-    validator = preventCast(validator);
-  }
-
-  validator = addDefault(createOrUpdate)(validator, metas);
-
-  return validator;
-};
-
-const createModelValidator =
-  (createOrUpdate) =>
-  ({ model, data, entity }, options) => {
-    const writableAttributes = model ? getWritableAttributes(model) : [];
-
-    const schema = writableAttributes.reduce((validators, attributeName) => {
-      const validator = createAttributeValidator(createOrUpdate)(
-        {
-          attr: model.attributes[attributeName],
-          updatedAttribute: { name: attributeName, value: prop(attributeName, data) },
-          model,
-          entity,
-        },
-        options
-      );
-
-      return assoc(attributeName, validator)(validators);
-    }, {});
-
-    return yup.object().shape(schema);
-  };
-
-const createValidateEntity =
-  (createOrUpdate) =>
-  async (model, data, { isDraft = false } = {}, entity = null) => {
-    if (!isObject(data)) {
-      const { displayName } = model.info;
-
-      throw new ValidationError(
-        `Invalid payload submitted for the ${createOrUpdate} of an entity of type ${displayName}. Expected an object, but got ${typeof data}`
-      );
-    }
-
-    const validator = createModelValidator(createOrUpdate)(
-      {
-        model,
-        data,
-        entity,
-      },
-      { isDraft }
-    )
-      .test('relations-test', 'check that all relations exist', async function (data) {
-        try {
-          await checkRelationsExist(buildRelationsStore({ uid: model.uid, data }));
-        } catch (e) {
-          return this.createError({
-            path: this.path,
-            message: e.message,
-          });
-        }
-        return true;
-      })
-      .required();
-
-    return validateYupSchema(validator, { strict: false, abortEarly: false })(data);
-  };
-
-/**
- * Builds an object containing all the media and relations being associated with an entity
- * @param {String} uid of the model
- * @param {Object} data
- * @returns {Object}
- */
-const buildRelationsStore = ({ uid, data }) => {
-  if (!uid) {
-    throw new ValidationError(`Cannot build relations store: "uid" is undefined`);
-  }
-
-  if (isEmpty(data)) {
-    return {};
-  }
-
-  const currentModel = strapi.getModel(uid);
-
-  return Object.keys(currentModel.attributes).reduce((result, attributeName) => {
-    const attribute = currentModel.attributes[attributeName];
-    const value = data[attributeName];
-
-    if (isNil(value)) {
-      return result;
-    }
-
-    switch (attribute.type) {
-      case 'relation':
-      case 'media': {
-        if (attribute.relation === 'morphToMany' || attribute.relation === 'morphToOne') {
-          // TODO: handle polymorphic relations
-          break;
-        }
-
-        const target = attribute.type === 'media' ? 'plugin::upload.file' : attribute.target;
-        // As there are multiple formats supported for associating relations
-        // with an entity, the value here can be an: array, object or number.
-        let source;
-        if (Array.isArray(value)) {
-          source = value;
-        } else if (isObject(value)) {
-          source = value.connect ?? value.set ?? [];
-        } else {
-          source = castArray(value);
-        }
-        const idArray = source.map((v) => ({ id: v.id || v }));
-
-        // Update the relationStore to keep track of all associations being made
-        // with relations and media.
-        result[target] = result[target] || [];
-        result[target].push(...idArray);
-        break;
-      }
-      case 'component': {
-        return castArray(value).reduce((relationsStore, componentValue) => {
-          if (!attribute.component) {
-            throw new ValidationError(
-              `Cannot build relations store from component, component identifier is undefined`
-            );
-          }
-
-          return mergeWith(
-            relationsStore,
-            buildRelationsStore({
-              uid: attribute.component,
-              data: componentValue,
-            }),
-            (objValue, srcValue) => {
-              if (isArray(objValue)) {
-                return objValue.concat(srcValue);
-              }
-            }
-          );
-        }, result);
-      }
-      case 'dynamiczone': {
-        return value.reduce((relationsStore, dzValue) => {
-          if (!dzValue.__component) {
-            throw new ValidationError(
-              `Cannot build relations store from dynamiczone, component identifier is undefined`
-            );
-          }
-
-          return mergeWith(
-            relationsStore,
-            buildRelationsStore({
-              uid: dzValue.__component,
-              data: dzValue,
-            }),
-            (objValue, srcValue) => {
-              if (isArray(objValue)) {
-                return objValue.concat(srcValue);
-              }
-            }
-          );
-        }, result);
-      }
-      default:
-        break;
-    }
-
-    return result;
-  }, {});
-};
-
-/**
- * Iterate through the relations store and validates that every relation or media
- * mentioned exists
- */
-const checkRelationsExist = async (relationsStore = {}) => {
-  const promises = [];
-
-  for (const [key, value] of Object.entries(relationsStore)) {
-    const evaluate = async () => {
-      const uniqueValues = uniqBy(value, `id`);
-      const count = await strapi.db.query(key).count({
-        where: {
-          id: {
-            $in: uniqueValues.map((v) => v.id),
-          },
-        },
-      });
-
-      if (count !== uniqueValues.length) {
-        throw new ValidationError(
-          `${
-            uniqueValues.length - count
-          } relation(s) of type ${key} associated with this entity do not exist`
-        );
-      }
-    };
-    promises.push(evaluate());
-  }
-
-  return Promise.all(promises);
-};
-
-module.exports = {
-  validateEntityCreation: createValidateEntity('creation'),
-  validateEntityUpdate: createValidateEntity('update'),
-};