@strapi/utils 4.11.3 → 4.12.0-beta.0

package/lib/traverse/query-fields.js

@@ -1,39 +0,0 @@
-'use strict';
-
-const { curry, isArray, isString, eq, trim, constant } = require('lodash/fp');
-
-const traverseFactory = require('./factory');
-
-const isStringArray = (value) => isArray(value) && value.every(isString);
-
-const fields = traverseFactory()
-  // Interecept array of strings
-  .intercept(isStringArray, async (visitor, options, fields, { recurse }) => {
-    return Promise.all(fields.map((field) => recurse(visitor, options, field)));
-  })
-  // Return wildcards as is
-  .intercept(eq('*'), constant('*'))
-  // Parse string values
-  // Since we're parsing strings only, each value should be an attribute name (and it's value, undefined),
-  // thus it shouldn't be possible to set a new value, and get should return the whole data if key === data
-  .parse(isString, () => ({
-    transform: trim,
-
-    remove(key, data) {
-      return data === key ? undefined : data;
-    },
-
-    set(_key, _value, data) {
-      return data;
-    },
-
-    keys(data) {
-      return [data];
-    },
-
-    get(key, data) {
-      return key === data ? data : undefined;
-    },
-  }));
-
-module.exports = curry(fields.traverse);

package/lib/traverse/query-filters.js

@@ -1,97 +0,0 @@
-'use strict';
-
-const { curry, isObject, isEmpty, isArray, isNil, cloneDeep } = require('lodash/fp');
-
-const traverseFactory = require('./factory');
-
-const filters = traverseFactory()
-  .intercept(
-    // Intercept filters arrays and apply the traversal to each one individually
-    isArray,
-    async (visitor, options, filters, { recurse }) => {
-      return Promise.all(
-        filters.map((filter, i) => {
-          // In filters, only operators such as $and, $in, $notIn or $or and implicit operators like [...]
-          // can have a value array, thus we can update the raw path but not the attribute one
-          const newPath = { ...options.path, raw: `${options.path.raw}[${i}]` };
-
-          return recurse(visitor, { ...options, path: newPath }, filter);
-        })
-        // todo: move that to the visitors
-      ).then((res) => res.filter((val) => !(isObject(val) && isEmpty(val))));
-    }
-  )
-  .intercept(
-    // Ignore non object filters and return the value as-is
-    (filters) => !isObject(filters),
-    (_, __, filters) => {
-      return filters;
-    }
-  )
-  // Parse object values
-  .parse(
-    (value) => typeof value === 'object',
-    () => ({
-      transform: cloneDeep,
-
-      remove(key, data) {
-        const { [key]: ignored, ...rest } = data;
-
-        return rest;
-      },
-
-      set(key, value, data) {
-        return { ...data, [key]: value };
-      },
-
-      keys(data) {
-        return Object.keys(data);
-      },
-
-      get(key, data) {
-        return data[key];
-      },
-    })
-  )
-  // Ignore null or undefined values
-  .ignore(({ value }) => isNil(value))
-  // Recursion on operators (non attributes)
-  .on(
-    ({ attribute }) => isNil(attribute),
-    async ({ key, visitor, path, value, schema }, { set, recurse }) => {
-      set(key, await recurse(visitor, { schema, path }, value));
-    }
-  )
-  // Handle relation recursion
-  .onRelation(async ({ key, attribute, visitor, path, value }, { set, recurse }) => {
-    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
-
-    if (isMorphRelation) {
-      return;
-    }
-
-    const targetSchemaUID = attribute.target;
-    const targetSchema = strapi.getModel(targetSchemaUID);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  })
-  .onComponent(async ({ key, attribute, visitor, path, value }, { set, recurse }) => {
-    const targetSchema = strapi.getModel(attribute.component);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  })
-  // Handle media recursion
-  .onMedia(async ({ key, visitor, path, value }, { set, recurse }) => {
-    const targetSchemaUID = 'plugin::upload.file';
-    const targetSchema = strapi.getModel(targetSchemaUID);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  });
-
-module.exports = curry(filters.traverse);

package/lib/traverse/query-populate.js

@@ -1,191 +0,0 @@
-'use strict';
-
-const {
-  curry,
-  isString,
-  isArray,
-  eq,
-  constant,
-  split,
-  isObject,
-  trim,
-  isNil,
-  cloneDeep,
-  join,
-  first,
-} = require('lodash/fp');
-
-const traverseFactory = require('./factory');
-
-const isKeyword =
-  (keyword) =>
-  ({ key, attribute }) => {
-    return !attribute && keyword === key;
-  };
-const isStringArray = (value) => isArray(value) && value.every(isString);
-
-const populate = traverseFactory()
-  // Array of strings ['foo', 'foo.bar'] => map(recurse), then filter out empty items
-  .intercept(isStringArray, async (visitor, options, populate, { recurse }) => {
-    return Promise.all(populate.map((nestedPopulate) => recurse(visitor, options, nestedPopulate)));
-  })
-  // Return wildcards as is
-  .intercept(eq('*'), constant('*'))
-  // Parse string values
-  .parse(isString, () => {
-    const tokenize = split('.');
-    const recompose = join('.');
-
-    return {
-      transform: trim,
-
-      remove(key, data) {
-        const [root] = tokenize(data);
-
-        return root === key ? undefined : data;
-      },
-
-      set(key, value, data) {
-        const [root] = tokenize(data);
-
-        if (root !== key) {
-          return data;
-        }
-
-        return isNil(value) ? root : `${root}.${value}`;
-      },
-
-      keys(data) {
-        return [first(tokenize(data))];
-      },
-
-      get(key, data) {
-        const [root, ...rest] = tokenize(data);
-
-        return key === root ? recompose(rest) : undefined;
-      },
-    };
-  })
-  // Parse object values
-  .parse(isObject, () => ({
-    transform: cloneDeep,
-
-    remove(key, data) {
-      const { [key]: ignored, ...rest } = data;
-
-      return rest;
-    },
-
-    set(key, value, data) {
-      return { ...data, [key]: value };
-    },
-
-    keys(data) {
-      return Object.keys(data);
-    },
-
-    get(key, data) {
-      return data[key];
-    },
-  }))
-  .ignore(({ key, attribute }) => {
-    return ['sort', 'filters', 'fields'].includes(key) && !attribute;
-  })
-  .on(
-    // Handle recursion on populate."populate"
-    isKeyword('populate'),
-    async ({ key, visitor, path, value, schema }, { set, recurse }) => {
-      const newValue = await recurse(visitor, { schema, path }, value);
-
-      set(key, newValue);
-    }
-  )
-  .on(isKeyword('on'), async ({ key, visitor, path, value }, { set, recurse }) => {
-    const newOn = {};
-
-    for (const [uid, subPopulate] of Object.entries(value)) {
-      const model = strapi.getModel(uid);
-      const newPath = { ...path, raw: `${path.raw}[${uid}]` };
-
-      const newSubPopulate = await recurse(visitor, { schema: model, path: newPath }, subPopulate);
-
-      newOn[uid] = newSubPopulate;
-    }
-
-    set(key, newOn);
-  })
-  // Handle populate on relation
-  .onRelation(async ({ key, value, attribute, visitor, path, schema }, { set, recurse }) => {
-    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
-
-    if (isMorphRelation) {
-      // Don't traverse values that cannot be parsed
-      if (!isObject(value) || !isObject(value?.on)) {
-        return;
-      }
-
-      // If there is a populate fragment defined, traverse it
-      const newValue = await recurse(visitor, { schema, path }, { on: value.on });
-
-      set(key, { on: newValue });
-    }
-
-    const targetSchemaUID = attribute.target;
-    const targetSchema = strapi.getModel(targetSchemaUID);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  })
-  // Handle populate on media
-  .onMedia(async ({ key, path, visitor, value }, { recurse, set }) => {
-    const targetSchemaUID = 'plugin::upload.file';
-    const targetSchema = strapi.getModel(targetSchemaUID);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  })
-  // Handle populate on components
-  .onComponent(async ({ key, value, visitor, path, attribute }, { recurse, set }) => {
-    const targetSchema = strapi.getModel(attribute.component);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  })
-  // Handle populate on dynamic zones
-  .onDynamicZone(async ({ key, value, attribute, schema, visitor, path }, { set, recurse }) => {
-    if (isObject(value)) {
-      const { components } = attribute;
-      const { on, ...properties } = value;
-
-      const newValue = {};
-
-      // Handle legacy DZ params
-      let newProperties = properties;
-
-      for (const componentUID of components) {
-        const componentSchema = strapi.getModel(componentUID);
-        newProperties = await recurse(visitor, { schema: componentSchema, path }, newProperties);
-      }
-
-      Object.assign(newValue, newProperties);
-
-      // Handle new morph fragment syntax
-      if (on) {
-        const newOn = await recurse(visitor, { schema, path }, { on });
-
-        // Recompose both syntaxes
-        Object.assign(newValue, newOn);
-      }
-
-      set(key, newValue);
-    } else {
-      const newValue = await recurse(visitor, { schema, path }, value);
-
-      set(key, newValue);
-    }
-  });
-
-module.exports = curry(populate.traverse);

package/lib/traverse/query-sort.js

@@ -1,171 +0,0 @@
-'use strict';
-
-const {
-  curry,
-  isString,
-  isObject,
-  map,
-  trim,
-  split,
-  isEmpty,
-  flatten,
-  pipe,
-  isNil,
-  first,
-  cloneDeep,
-} = require('lodash/fp');
-
-const traverseFactory = require('./factory');
-
-const ORDERS = { asc: 'asc', desc: 'desc' };
-const ORDER_VALUES = Object.values(ORDERS);
-
-const isSortOrder = (value) => ORDER_VALUES.includes(value.toLowerCase());
-const isStringArray = (value) => Array.isArray(value) && value.every(isString);
-const isObjectArray = (value) => Array.isArray(value) && value.every(isObject);
-const isNestedSorts = (value) => isString(value) && value.split(',').length > 1;
-
-const sort = traverseFactory()
-  .intercept(
-    // String with chained sorts (foo,bar,foobar) => split, map(recurse), then recompose
-    isNestedSorts,
-    async (visitor, options, sort, { recurse }) => {
-      return Promise.all(
-        sort
-          .split(',')
-          .map(trim)
-          .map((nestedSort) => recurse(visitor, options, nestedSort))
-      ).then((res) => res.filter((part) => !isEmpty(part)).join(','));
-    }
-  )
-  .intercept(
-    // Array of strings ['foo', 'foo,bar'] => map(recurse), then filter out empty items
-    isStringArray,
-    async (visitor, options, sort, { recurse }) => {
-      return Promise.all(sort.map((nestedSort) => recurse(visitor, options, nestedSort))).then(
-        (res) => res.filter((nestedSort) => !isEmpty(nestedSort))
-      );
-    }
-  )
-  .intercept(
-    // Array of objects [{ foo: 'asc' }, { bar: 'desc', baz: 'asc' }] => map(recurse), then filter out empty items
-    isObjectArray,
-    async (visitor, options, sort, { recurse }) => {
-      return Promise.all(sort.map((nestedSort) => recurse(visitor, options, nestedSort))).then(
-        (res) => res.filter((nestedSort) => !isEmpty(nestedSort))
-      );
-    }
-  )
-  // Parse string values
-  .parse(
-    (sort) => typeof sort === 'string',
-    () => {
-      const tokenize = pipe(split('.'), map(split(':')), flatten);
-      const recompose = (parts) => {
-        if (parts.length === 0) {
-          return undefined;
-        }
-
-        return parts.reduce((acc, part) => {
-          if (isEmpty(part)) {
-            return acc;
-          }
-
-          if (acc === '') {
-            return part;
-          }
-
-          return isSortOrder(part) ? `${acc}:${part}` : `${acc}.${part}`;
-        }, '');
-      };
-
-      return {
-        transform: trim,
-
-        remove(key, data) {
-          const [root] = tokenize(data);
-
-          return root === key ? undefined : data;
-        },
-
-        set(key, value, data) {
-          const [root] = tokenize(data);
-
-          if (root !== key) {
-            return data;
-          }
-
-          return isNil(value) ? root : `${root}.${value}`;
-        },
-
-        keys(data) {
-          return [first(tokenize(data))];
-        },
-
-        get(key, data) {
-          const [root, ...rest] = tokenize(data);
-
-          return key === root ? recompose(rest) : undefined;
-        },
-      };
-    }
-  )
-  // Parse object values
-  .parse(
-    (value) => typeof value === 'object',
-    () => ({
-      transform: cloneDeep,
-
-      remove(key, data) {
-        const { [key]: ignored, ...rest } = data;
-
-        return rest;
-      },
-
-      set(key, value, data) {
-        return { ...data, [key]: value };
-      },
-
-      keys(data) {
-        return Object.keys(data);
-      },
-
-      get(key, data) {
-        return data[key];
-      },
-    })
-  )
-  // Handle deep sort on relation
-  .onRelation(async ({ key, value, attribute, visitor, path }, { set, recurse }) => {
-    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
-
-    if (isMorphRelation) {
-      return;
-    }
-
-    const targetSchemaUID = attribute.target;
-    const targetSchema = strapi.getModel(targetSchemaUID);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  })
-  // Handle deep sort on media
-  .onMedia(async ({ key, path, visitor, value }, { recurse, set }) => {
-    const targetSchemaUID = 'plugin::upload.file';
-    const targetSchema = strapi.getModel(targetSchemaUID);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  })
-  // Handle deep sort on components
-  .onComponent(async ({ key, value, visitor, path, attribute }, { recurse, set }) => {
-    const targetSchema = strapi.getModel(attribute.component);
-
-    const newValue = await recurse(visitor, { schema: targetSchema, path }, value);
-
-    set(key, newValue);
-  });
-
-module.exports = curry(sort.traverse);

package/lib/traverse-entity.js

@@ -1,166 +0,0 @@
-'use strict';
-
-const { clone, isObject, isArray, isNil, curry } = require('lodash/fp');
-
-const traverseMorphRelationTarget = async (visitor, path, entry) => {
-  const targetSchema = strapi.getModel(entry.__type);
-
-  const traverseOptions = { schema: targetSchema, path };
-
-  return traverseEntity(visitor, traverseOptions, entry);
-};
-
-const traverseRelationTarget = (schema) => async (visitor, path, entry) => {
-  const traverseOptions = { schema, path };
-
-  return traverseEntity(visitor, traverseOptions, entry);
-};
-
-const traverseMediaTarget = async (visitor, path, entry) => {
-  const targetSchemaUID = 'plugin::upload.file';
-  const targetSchema = strapi.getModel(targetSchemaUID);
-
-  const traverseOptions = { schema: targetSchema, path };
-
-  return traverseEntity(visitor, traverseOptions, entry);
-};
-
-const traverseComponent = async (visitor, path, schema, entry) => {
-  const traverseOptions = { schema, path };
-
-  return traverseEntity(visitor, traverseOptions, entry);
-};
-
-const visitDynamicZoneEntry = async (visitor, path, entry) => {
-  const targetSchema = strapi.getModel(entry.__component);
-  const traverseOptions = { schema: targetSchema, path };
-
-  return traverseEntity(visitor, traverseOptions, entry);
-};
-
-const traverseEntity = async (visitor, options, entity) => {
-  const { path = { raw: null, attribute: null }, schema } = options;
-
-  // End recursion
-  if (!isObject(entity) || isNil(schema)) {
-    return entity;
-  }
-
-  // Don't mutate the original entity object
-  // only clone at 1st level as the next level will get clone when traversed
-  const copy = clone(entity);
-  const visitorUtils = createVisitorUtils({ data: copy });
-
-  const keys = Object.keys(copy);
-  for (let i = 0; i < keys.length; i += 1) {
-    const key = keys[i];
-    // Retrieve the attribute definition associated to the key from the schema
-    const attribute = schema.attributes[key];
-
-    // If the attribute doesn't exist within the schema, ignore it
-    if (isNil(attribute)) {
-      continue;
-    }
-
-    const newPath = { ...path };
-
-    newPath.raw = isNil(path.raw) ? key : `${path.raw}.${key}`;
-
-    if (!isNil(attribute)) {
-      newPath.attribute = isNil(path.attribute) ? key : `${path.attribute}.${key}`;
-    }
-
-    // Visit the current attribute
-    const visitorOptions = { data: copy, schema, key, value: copy[key], attribute, path: newPath };
-
-    await visitor(visitorOptions, visitorUtils);
-
-    // Extract the value for the current key (after calling the visitor)
-    const value = copy[key];
-
-    // Ignore Nil values
-    if (isNil(value)) {
-      continue;
-    }
-
-    const isRelation = attribute.type === 'relation';
-    const isComponent = attribute.type === 'component';
-    const isDynamicZone = attribute.type === 'dynamiczone';
-    const isMedia = attribute.type === 'media';
-
-    if (isRelation) {
-      const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
-
-      const method = isMorphRelation
-        ? traverseMorphRelationTarget
-        : traverseRelationTarget(strapi.getModel(attribute.target));
-
-      if (isArray(value)) {
-        const res = new Array(value.length);
-        for (let i = 0; i < value.length; i += 1) {
-          res[i] = await method(visitor, newPath, value[i]);
-        }
-        copy[key] = res;
-      } else {
-        copy[key] = await method(visitor, newPath, value);
-      }
-
-      continue;
-    }
-
-    if (isMedia) {
-      // need to update copy
-      if (isArray(value)) {
-        const res = new Array(value.length);
-        for (let i = 0; i < value.length; i += 1) {
-          res[i] = await traverseMediaTarget(visitor, newPath, value[i]);
-        }
-        copy[key] = res;
-      } else {
-        copy[key] = await traverseMediaTarget(visitor, newPath, value);
-      }
-
-      continue;
-    }
-
-    if (isComponent) {
-      const targetSchema = strapi.getModel(attribute.component);
-
-      if (isArray(value)) {
-        const res = new Array(value.length);
-        for (let i = 0; i < value.length; i += 1) {
-          res[i] = await traverseComponent(visitor, newPath, targetSchema, value[i]);
-        }
-        copy[key] = res;
-      } else {
-        copy[key] = await traverseComponent(visitor, newPath, targetSchema, value);
-      }
-
-      continue;
-    }
-
-    if (isDynamicZone && isArray(value)) {
-      const res = new Array(value.length);
-      for (let i = 0; i < value.length; i += 1) {
-        res[i] = await visitDynamicZoneEntry(visitor, newPath, value[i]);
-      }
-      copy[key] = res;
-
-      continue;
-    }
-  }
-
-  return copy;
-};
-
-const createVisitorUtils = ({ data }) => ({
-  remove(key) {
-    delete data[key];
-  },
-
-  set(key, value) {
-    data[key] = value;
-  },
-});
-
-module.exports = curry(traverseEntity);