@strapi/utils 5.1.1 → 5.2.0

package/dist/index.js

@@ -1550,7 +1550,7 @@ const traverseFactory = () => {
     }
   };
   const traverse = async (visitor2, options, data) => {
-    const { path = DEFAULT_PATH, schema, getModel } = options ?? {};
+    const { path = DEFAULT_PATH, parent, schema, getModel } = options ?? {};
     for (const { predicate, handler } of state.interceptors) {
       if (predicate(data)) {
         return handler(visitor2, options, data, { recurse: traverse });
@@ -1577,7 +1577,8 @@ const traverseFactory = () => {
         schema,
         path: newPath,
         data: out,
-        getModel
+        getModel,
+        parent
       };
       const transformUtils = {
         remove(key2) {
@@ -1598,7 +1599,8 @@ const traverseFactory = () => {
         path: newPath,
         data: out,
         visitor: visitor2,
-        getModel
+        getModel,
+        parent
       });
       const ignoreCtx = createContext();
       const shouldIgnore = state.ignore.some((predicate) => predicate(ignoreCtx));
@@ -1687,26 +1689,46 @@ const filters = traverseFactory().intercept(
   }
 })).ignore(({ value }) => fp.isNil(value)).on(
   ({ attribute }) => fp.isNil(attribute),
-  async ({ key, visitor: visitor2, path, value, schema, getModel }, { set, recurse }) => {
-    set(key, await recurse(visitor2, { schema, path, getModel }, value));
+  async ({ key, visitor: visitor2, path, value, schema, getModel, attribute }, { set, recurse }) => {
+    const parent = { key, path, schema, attribute };
+    set(key, await recurse(visitor2, { schema, path, getModel, parent }, value));
+  }
+).onRelation(
+  async ({ key, attribute, visitor: visitor2, path, value, schema, getModel }, { set, recurse }) => {
+    const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
+    if (isMorphRelation) {
+      return;
+    }
+    const parent = { key, path, schema, attribute };
+    const targetSchemaUID = attribute.target;
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(
+      visitor2,
+      { schema: targetSchema, path, getModel, parent },
+      value
+    );
+    set(key, newValue);
   }
-).onRelation(async ({ key, attribute, visitor: visitor2, path, value, getModel }, { set, recurse }) => {
-  const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
-  if (isMorphRelation) {
-    return;
+).onComponent(
+  async ({ key, attribute, visitor: visitor2, path, schema, value, getModel }, { set, recurse }) => {
+    const parent = { key, path, schema, attribute };
+    const targetSchema = getModel(attribute.component);
+    const newValue = await recurse(
+      visitor2,
+      { schema: targetSchema, path, getModel, parent },
+      value
+    );
+    set(key, newValue);
   }
-  const targetSchemaUID = attribute.target;
-  const targetSchema = getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
-  set(key, newValue);
-}).onComponent(async ({ key, attribute, visitor: visitor2, path, value, getModel }, { set, recurse }) => {
-  const targetSchema = getModel(attribute.component);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
-  set(key, newValue);
-}).onMedia(async ({ key, visitor: visitor2, path, value, getModel }, { set, recurse }) => {
+).onMedia(async ({ key, visitor: visitor2, path, schema, attribute, value, getModel }, { set, recurse }) => {
+  const parent = { key, path, schema, attribute };
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
+  const newValue = await recurse(
+    visitor2,
+    { schema: targetSchema, path, getModel, parent },
+    value
+  );
   set(key, newValue);
 });
 const traverseQueryFilters = fp.curry(filters.traverse);
@@ -1794,66 +1816,91 @@ const sort = traverseFactory().intercept(
   get(key, data) {
     return data[key];
   }
-})).onRelation(async ({ key, value, attribute, visitor: visitor2, path, getModel }, { set, recurse }) => {
-  const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
-  if (isMorphRelation) {
-    return;
+})).onRelation(
+  async ({ key, value, attribute, visitor: visitor2, path, getModel, schema }, { set, recurse }) => {
+    const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
+    if (isMorphRelation) {
+      return;
+    }
+    const parent = { key, path, schema, attribute };
+    const targetSchemaUID = attribute.target;
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(
+      visitor2,
+      { schema: targetSchema, path, getModel, parent },
+      value
+    );
+    set(key, newValue);
   }
-  const targetSchemaUID = attribute.target;
-  const targetSchema = getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
-  set(key, newValue);
-}).onMedia(async ({ key, path, visitor: visitor2, value, getModel }, { recurse, set }) => {
+).onMedia(async ({ key, path, schema, attribute, visitor: visitor2, value, getModel }, { recurse, set }) => {
+  const parent = { key, path, schema, attribute };
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
-  set(key, newValue);
-}).onComponent(async ({ key, value, visitor: visitor2, path, attribute, getModel }, { recurse, set }) => {
-  const targetSchema = getModel(attribute.component);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
+  const newValue = await recurse(
+    visitor2,
+    { schema: targetSchema, path, getModel, parent },
+    value
+  );
   set(key, newValue);
-});
+}).onComponent(
+  async ({ key, value, visitor: visitor2, path, schema, attribute, getModel }, { recurse, set }) => {
+    const parent = { key, path, schema, attribute };
+    const targetSchema = getModel(attribute.component);
+    const newValue = await recurse(
+      visitor2,
+      { schema: targetSchema, path, getModel, parent },
+      value
+    );
+    set(key, newValue);
+  }
+);
 const traverseQuerySort = fp.curry(sort.traverse);
 const isKeyword = (keyword) => {
   return ({ key, attribute }) => {
     return !attribute && keyword === key;
   };
 };
+const isWildcard = (value) => value === "*";
+const isPopulateString = (value) => {
+  return fp.isString(value) && !isWildcard(value);
+};
 const isStringArray$1 = (value) => fp.isArray(value) && value.every(fp.isString);
 const isObj = (value) => fp.isObject(value);
-const populate = traverseFactory().intercept(isStringArray$1, async (visitor2, options, populate2, { recurse }) => {
-  const visitedPopulate = await Promise.all(
-    populate2.map((nestedPopulate) => recurse(visitor2, options, nestedPopulate))
+const populate = traverseFactory().intercept(isPopulateString, async (visitor2, options, populate2, { recurse }) => {
+  const populateObject = pathsToObjectPopulate([populate2]);
+  const traversedPopulate = await recurse(visitor2, options, populateObject);
+  const [result] = objectPopulateToPaths(traversedPopulate);
+  return result;
+}).intercept(isStringArray$1, async (visitor2, options, populate2, { recurse }) => {
+  const paths = await Promise.all(
+    populate2.map((subClause) => recurse(visitor2, options, subClause))
   );
-  return visitedPopulate.filter((item) => !fp.isNil(item));
-}).parse(
-  (value) => value === "*",
-  () => ({
-    /**
-     * Since value is '*', we don't need to transform it
-     */
-    transform: fp.identity,
-    /**
-     * '*' isn't a key/value structure, so regardless
-     *  of the given key, it returns the data ('*')
-     */
-    get: (_key, data) => data,
-    /**
-     * '*' isn't a key/value structure, so regardless
-     * of the given `key`, use `value` as the new `data`
-     */
-    set: (_key, value) => value,
-    /**
-     * '*' isn't a key/value structure, but we need to simulate at least one to enable
-     * the data traversal. We're using '' since it represents a falsy string value
-     */
-    keys: fp.constant([""]),
-    /**
-     * Removing '*' means setting it to undefined, regardless of the given key
-     */
-    remove: fp.constant(void 0)
-  })
-).parse(fp.isString, () => {
+  return paths.filter((item) => !fp.isNil(item));
+}).parse(isWildcard, () => ({
+  /**
+   * Since value is '*', we don't need to transform it
+   */
+  transform: fp.identity,
+  /**
+   * '*' isn't a key/value structure, so regardless
+   *  of the given key, it returns the data ('*')
+   */
+  get: (_key, data) => data,
+  /**
+   * '*' isn't a key/value structure, so regardless
+   * of the given `key`, use `value` as the new `data`
+   */
+  set: (_key, value) => value,
+  /**
+   * '*' isn't a key/value structure, but we need to simulate at least one to enable
+   * the data traversal. We're using '' since it represents a falsy string value
+   */
+  keys: fp.constant([""]),
+  /**
+   * Removing '*' means setting it to undefined, regardless of the given key
+   */
+  remove: fp.constant(void 0)
+})).parse(fp.isString, () => {
   const tokenize = fp.split(".");
   const recompose = fp.join(".");
   return {
@@ -1898,64 +1945,127 @@ const populate = traverseFactory().intercept(isStringArray$1, async (visitor2, o
 }).on(
   // Handle recursion on populate."populate"
   isKeyword("populate"),
-  async ({ key, visitor: visitor2, path, value, schema, getModel }, { set, recurse }) => {
-    const newValue = await recurse(visitor2, { schema, path, getModel }, value);
+  async ({ key, visitor: visitor2, path, value, schema, getModel, attribute }, { set, recurse }) => {
+    const parent = { key, path, schema, attribute };
+    const newValue = await recurse(visitor2, { schema, path, getModel, parent }, value);
     set(key, newValue);
   }
-).on(isKeyword("on"), async ({ key, visitor: visitor2, path, value, getModel }, { set, recurse }) => {
-  const newOn = {};
-  if (!isObj(value)) {
-    return;
-  }
-  for (const [uid, subPopulate] of Object.entries(value)) {
-    const model = getModel(uid);
-    const newPath = { ...path, raw: `${path.raw}[${uid}]` };
-    newOn[uid] = await recurse(visitor2, { schema: model, path: newPath, getModel }, subPopulate);
+).on(
+  isKeyword("on"),
+  async ({ key, visitor: visitor2, path, value, getModel, parent }, { set, recurse }) => {
+    const newOn = {};
+    if (!isObj(value)) {
+      return;
+    }
+    for (const [uid, subPopulate] of Object.entries(value)) {
+      const model = getModel(uid);
+      const newPath = { ...path, raw: `${path.raw}[${uid}]` };
+      newOn[uid] = await recurse(
+        visitor2,
+        { schema: model, path: newPath, getModel, parent },
+        subPopulate
+      );
+    }
+    set(key, newOn);
   }
-  set(key, newOn);
-}).onRelation(
+).onRelation(
   async ({ key, value, attribute, visitor: visitor2, path, schema, getModel }, { set, recurse }) => {
     if (fp.isNil(value)) {
       return;
     }
+    const parent = { key, path, schema, attribute };
     if (isMorphToRelationalAttribute(attribute)) {
       if (!fp.isObject(value) || !("on" in value && fp.isObject(value?.on))) {
         return;
       }
-      const newValue2 = await recurse(visitor2, { schema, path, getModel }, { on: value?.on });
+      const newValue2 = await recurse(
+        visitor2,
+        { schema, path, getModel, parent },
+        { on: value?.on }
+      );
       set(key, newValue2);
       return;
     }
     const targetSchemaUID = attribute.target;
     const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
+    const newValue = await recurse(
+      visitor2,
+      { schema: targetSchema, path, getModel, parent },
+      value
+    );
     set(key, newValue);
   }
-).onMedia(async ({ key, path, visitor: visitor2, value, getModel }, { recurse, set }) => {
+).onMedia(async ({ key, path, schema, attribute, visitor: visitor2, value, getModel }, { recurse, set }) => {
   if (fp.isNil(value)) {
     return;
   }
+  const parent = { key, path, schema, attribute };
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
-  set(key, newValue);
-}).onComponent(async ({ key, value, visitor: visitor2, path, attribute, getModel }, { recurse, set }) => {
-  if (fp.isNil(value)) {
-    return;
-  }
-  const targetSchema = getModel(attribute.component);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
+  const newValue = await recurse(
+    visitor2,
+    { schema: targetSchema, path, getModel, parent },
+    value
+  );
   set(key, newValue);
-}).onDynamicZone(async ({ key, value, schema, visitor: visitor2, path, getModel }, { set, recurse }) => {
-  if (fp.isNil(value) || !fp.isObject(value)) {
-    return;
+}).onComponent(
+  async ({ key, value, schema, visitor: visitor2, path, attribute, getModel }, { recurse, set }) => {
+    if (fp.isNil(value)) {
+      return;
+    }
+    const parent = { key, path, schema, attribute };
+    const targetSchema = getModel(attribute.component);
+    const newValue = await recurse(
+      visitor2,
+      { schema: targetSchema, path, getModel, parent },
+      value
+    );
+    set(key, newValue);
   }
-  if ("on" in value && value.on) {
-    const newOn = await recurse(visitor2, { schema, path, getModel }, { on: value.on });
-    set(key, newOn);
+).onDynamicZone(
+  async ({ key, value, schema, visitor: visitor2, path, attribute, getModel }, { set, recurse }) => {
+    if (fp.isNil(value) || !fp.isObject(value)) {
+      return;
+    }
+    const parent = { key, path, schema, attribute };
+    if ("on" in value && value.on) {
+      const newOn = await recurse(visitor2, { schema, path, getModel, parent }, { on: value.on });
+      set(key, newOn);
+    }
   }
-});
+);
 const traverseQueryPopulate = fp.curry(populate.traverse);
+const objectPopulateToPaths = (input) => {
+  const paths = [];
+  function traverse(currentObj, parentPath) {
+    for (const [key, value] of Object.entries(currentObj)) {
+      const currentPath = parentPath ? `${parentPath}.${key}` : key;
+      if (value === true) {
+        paths.push(currentPath);
+      } else {
+        traverse(value.populate, currentPath);
+      }
+    }
+  }
+  traverse(input, "");
+  return paths;
+};
+const pathsToObjectPopulate = (input) => {
+  const result = {};
+  function traverse(object, keys) {
+    const [first2, ...rest] = keys;
+    if (rest.length === 0) {
+      object[first2] = true;
+    } else {
+      if (!object[first2] || typeof object[first2] === "boolean") {
+        object[first2] = { populate: {} };
+      }
+      traverse(object[first2].populate, rest);
+    }
+  }
+  input.forEach((clause) => traverse(result, clause.split(".")));
+  return result;
+};
 const isStringArray = (value) => {
   return fp.isArray(value) && value.every(fp.isString);
 };
@@ -2101,21 +2211,22 @@ const defaultSanitizePopulate = fp.curry((ctx, populate2) => {
   }
   return pipe(
     traverseQueryPopulate(visitor$4, ctx),
-    traverseQueryPopulate(async ({ key, value, schema, attribute, getModel }, { set }) => {
+    traverseQueryPopulate(async ({ key, value, schema, attribute, getModel, path }, { set }) => {
       if (attribute) {
         return;
       }
+      const parent = { key, path, schema, attribute };
       if (key === "sort") {
-        set(key, await defaultSanitizeSort({ schema, getModel }, value));
+        set(key, await defaultSanitizeSort({ schema, getModel, parent }, value));
       }
       if (key === "filters") {
-        set(key, await defaultSanitizeFilters({ schema, getModel }, value));
+        set(key, await defaultSanitizeFilters({ schema, getModel, parent }, value));
       }
       if (key === "fields") {
-        set(key, await defaultSanitizeFields({ schema, getModel }, value));
+        set(key, await defaultSanitizeFields({ schema, getModel, parent }, value));
       }
       if (key === "populate") {
-        set(key, await defaultSanitizePopulate({ schema, getModel }, value));
+        set(key, await defaultSanitizePopulate({ schema, getModel, parent }, value));
       }
     }, ctx),
     // Remove private fields
@@ -2468,12 +2579,6 @@ const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   throwUnrecognizedFields
 }, Symbol.toStringTag, { value: "Module" }));
 const { ID_ATTRIBUTE: ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$1 } = constants$1;
-const throwPasswords = (ctx) => async (entity) => {
-  if (!ctx.schema) {
-    throw new Error("Missing schema in throwPasswords");
-  }
-  return traverseEntity$1(visitor$3, ctx, entity);
-};
 const FILTER_TRAVERSALS = [
   "nonAttributesOperators",
   "dynamicZones",
@@ -2622,110 +2727,118 @@ const validatePopulate = asyncCurry(
     }
     const functionsToApply = [];
     functionsToApply.push(
-      traverseQueryPopulate(async ({ key, path, value, schema, attribute, getModel }, { set }) => {
-        if (attribute) {
-          const isPopulatableAttribute = ["relation", "dynamiczone", "component", "media"].includes(
-            attribute.type
-          );
-          if (!isPopulatableAttribute) {
-            throwInvalidKey({ key, path: path.raw });
+      traverseQueryPopulate(
+        async ({ key, path, value, schema, attribute, getModel, parent }, { set }) => {
+          if (!parent?.attribute && attribute) {
+            const isPopulatableAttribute = [
+              "relation",
+              "dynamiczone",
+              "component",
+              "media"
+            ].includes(attribute.type);
+            if (!isPopulatableAttribute) {
+              throwInvalidKey({ key, path: path.raw });
+            }
+            return;
           }
-          return;
-        }
-        if (key === "on") {
-          if (!fp.isObject(value)) {
-            return throwInvalidKey({ key, path: path.raw });
+          if (key === "on") {
+            if (!fp.isObject(value)) {
+              return throwInvalidKey({ key, path: path.raw });
+            }
+            const targets = Object.keys(value);
+            for (const target of targets) {
+              const model = getModel(target);
+              if (!model) {
+                throwInvalidKey({ key: target, path: `${path.raw}.${target}` });
+              }
+            }
+            return;
           }
-          const targets = Object.keys(value);
-          for (const target of targets) {
-            const model = getModel(target);
-            if (!model) {
-              throwInvalidKey({ key: target, path: `${path.raw}.${target}` });
+          if (key === "" && value === "*") {
+            return;
+          }
+          if (key === "count") {
+            try {
+              parseType({ type: "boolean", value });
+              return;
+            } catch {
+              throwInvalidKey({ key, path: path.attribute });
             }
           }
-          return;
-        }
-        if (key === "" && value === "*") {
-          return;
-        }
-        if (key === "count") {
           try {
-            parseType({ type: "boolean", value });
+            parseType({ type: "boolean", value: key });
             return;
           } catch {
+          }
+          if (key === "sort") {
+            set(
+              key,
+              await validateSort(
+                {
+                  schema,
+                  getModel
+                },
+                value,
+                // pass the sort value
+                includes?.sort || SORT_TRAVERSALS
+              )
+            );
+            return;
+          }
+          if (key === "filters") {
+            set(
+              key,
+              await validateFilters(
+                {
+                  schema,
+                  getModel
+                },
+                value,
+                // pass the filters value
+                includes?.filters || FILTER_TRAVERSALS
+              )
+            );
+            return;
+          }
+          if (key === "fields") {
+            set(
+              key,
+              await validateFields(
+                {
+                  schema,
+                  getModel
+                },
+                value,
+                // pass the fields value
+                includes?.fields || FIELDS_TRAVERSALS
+              )
+            );
+            return;
+          }
+          if (key === "populate") {
+            set(
+              key,
+              await validatePopulate(
+                {
+                  schema,
+                  getModel,
+                  parent: { key, path, schema, attribute },
+                  path
+                },
+                value,
+                // pass the nested populate value
+                includes
+                // pass down the same includes object
+              )
+            );
+            return;
+          }
+          if (includes?.populate?.includes("nonAttributesOperators")) {
             throwInvalidKey({ key, path: path.attribute });
           }
-        }
-        try {
-          parseType({ type: "boolean", value: key });
-          return;
-        } catch {
-        }
-        if (key === "sort") {
-          set(
-            key,
-            await validateSort(
-              {
-                schema,
-                getModel
-              },
-              value,
-              // pass the sort value
-              includes?.sort || SORT_TRAVERSALS
-            )
-          );
-          return;
-        }
-        if (key === "filters") {
-          set(
-            key,
-            await validateFilters(
-              {
-                schema,
-                getModel
-              },
-              value,
-              // pass the filters value
-              includes?.filters || FILTER_TRAVERSALS
-            )
-          );
-          return;
-        }
-        if (key === "fields") {
-          set(
-            key,
-            await validateFields(
-              {
-                schema,
-                getModel
-              },
-              value,
-              // pass the fields value
-              includes?.fields || FIELDS_TRAVERSALS
-            )
-          );
-          return;
-        }
-        if (key === "populate") {
-          set(
-            key,
-            await validatePopulate(
-              {
-                schema,
-                getModel
-              },
-              value,
-              // pass the nested populate value
-              includes
-              // pass down the same includes object
-            )
-          );
-          return;
-        }
-        if (includes?.populate?.includes("nonAttributesOperators")) {
-          throwInvalidKey({ key, path: path.attribute });
-        }
-      }, ctx)
+        },
+        ctx
+      )
     );
     if (includes?.populate?.includes("private")) {
       functionsToApply.push(traverseQueryPopulate(visitor$2, ctx));
@@ -2757,7 +2870,6 @@ const validators = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   defaultValidateFilters,
   defaultValidatePopulate,
   defaultValidateSort,
-  throwPasswords,
   validateFields,
   validateFilters,
   validatePopulate,