@fourlights/strapi-plugin-deep-populate 1.5.0 → 1.6.0

package/dist/server/index.js

@@ -21,6 +21,7 @@ const require$$2$1 = require("util");
 const require$$0$8 = require("constants");
 require("node:stream");
 const cloneDeep = require("lodash/cloneDeep");
+const unset = require("lodash/unset");
 const get = require("lodash/get");
 const mergeWith = require("lodash/mergeWith");
 const set$2 = require("lodash/set");
@@ -45,6 +46,7 @@ const require$$0__default$5 = /* @__PURE__ */ _interopDefault(require$$0$6);
 const require$$2__default$1 = /* @__PURE__ */ _interopDefault(require$$2$1);
 const require$$0__default$7 = /* @__PURE__ */ _interopDefault(require$$0$8);
 const cloneDeep__default = /* @__PURE__ */ _interopDefault(cloneDeep);
+const unset__default = /* @__PURE__ */ _interopDefault(unset);
 const get__default = /* @__PURE__ */ _interopDefault(get);
 const mergeWith__default = /* @__PURE__ */ _interopDefault(mergeWith);
 const set__default = /* @__PURE__ */ _interopDefault(set$2);
@@ -12941,12 +12943,12 @@ const utils = {
     return new Date(getKey(key));
   },
   /**
-   * Gets a value from env that matches oneOf provided values
-   * @param {string} key
-   * @param {string[]} expectedValues
-   * @param {string|undefined} defaultValue
-   * @returns {string|undefined}
-   */
+  * Gets a value from env that matches oneOf provided values
+  * @param {string} key
+  * @param {string[]} expectedValues
+  * @param {string|undefined} defaultValue
+  * @returns {string|undefined}
+  */
   oneOf(key, expectedValues, defaultValue) {
     if (!expectedValues) {
       throw new Error(`env.oneOf requires expectedValues`);
@@ -13001,11 +13003,7 @@ const getCreatorFields = (model) => {
 };
 const getNonWritableAttributes = (model) => {
   if (!model) return [];
-  const nonWritableAttributes = ___default__default.default.reduce(
-    model.attributes,
-    (acc, attr, attrName) => attr.writable === false ? acc.concat(attrName) : acc,
-    []
-  );
+  const nonWritableAttributes = ___default__default.default.reduce(model.attributes, (acc, attr, attrName) => attr.writable === false ? acc.concat(attrName) : acc, []);
   return ___default__default.default.uniq([
     ID_ATTRIBUTE$4,
     DOC_ID_ATTRIBUTE$4,
@@ -13021,12 +13019,13 @@ const isWritableAttribute = (model, attributeName) => {
   return getWritableAttributes(model).includes(attributeName);
 };
 const getNonVisibleAttributes = (model) => {
-  const nonVisibleAttributes = ___default__default.default.reduce(
-    model.attributes,
-    (acc, attr, attrName) => attr.visible === false ? acc.concat(attrName) : acc,
-    []
-  );
-  return ___default__default.default.uniq([ID_ATTRIBUTE$4, DOC_ID_ATTRIBUTE$4, ...getTimestamps(model), ...nonVisibleAttributes]);
+  const nonVisibleAttributes = ___default__default.default.reduce(model.attributes, (acc, attr, attrName) => attr.visible === false ? acc.concat(attrName) : acc, []);
+  return ___default__default.default.uniq([
+    ID_ATTRIBUTE$4,
+    DOC_ID_ATTRIBUTE$4,
+    ...getTimestamps(model),
+    ...nonVisibleAttributes
+  ]);
 };
 const getVisibleAttributes = (model) => {
   return ___default__default.default.difference(___default__default.default.keys(model.attributes), getNonVisibleAttributes(model));
@@ -13034,11 +13033,16 @@ const getVisibleAttributes = (model) => {
 const isVisibleAttribute = (model, attributeName) => {
   return getVisibleAttributes(model).includes(attributeName);
 };
-const getOptions = (model) => ___default__default.default.assign({ draftAndPublish: false }, ___default__default.default.get(model, "options", {}));
+const getOptions = (model) => ___default__default.default.assign({
+  draftAndPublish: false
+}, ___default__default.default.get(model, "options", {}));
 const hasDraftAndPublish = (model) => ___default__default.default.get(model, "options.draftAndPublish", false) === true;
 const isDraft = (data, model) => hasDraftAndPublish(model) && ___default__default.default.get(data, PUBLISHED_AT_ATTRIBUTE$1) === null;
 const isSchema = (data) => {
-  return typeof data === "object" && data !== null && "modelType" in data && typeof data.modelType === "string" && ["component", "contentType"].includes(data.modelType);
+  return typeof data === "object" && data !== null && "modelType" in data && typeof data.modelType === "string" && [
+    "component",
+    "contentType"
+  ].includes(data.modelType);
 };
 const isComponentSchema = (data) => {
   return isSchema(data) && data.modelType === "component";
@@ -13049,15 +13053,9 @@ const isContentTypeSchema = (data) => {
 const isSingleType = ({ kind = COLLECTION_TYPE }) => kind === SINGLE_TYPE;
 const isCollectionType = ({ kind = COLLECTION_TYPE }) => kind === COLLECTION_TYPE;
 const isKind = (kind) => (model) => model.kind === kind;
-const getStoredPrivateAttributes = (model) => fp.union(
-  strapi?.config?.get("api.responses.privateAttributes", []) ?? [],
-  fp.getOr([], "options.privateAttributes", model)
-);
+const getStoredPrivateAttributes = (model) => fp.union(strapi?.config?.get("api.responses.privateAttributes", []) ?? [], fp.getOr([], "options.privateAttributes", model));
 const getPrivateAttributes = (model) => {
-  return ___default__default.default.union(
-    getStoredPrivateAttributes(model),
-    ___default__default.default.keys(___default__default.default.pickBy(model.attributes, (attr) => !!attr.private))
-  );
+  return ___default__default.default.union(getStoredPrivateAttributes(model), ___default__default.default.keys(___default__default.default.pickBy(model.attributes, (attr) => !!attr.private)));
 };
 const isPrivateAttribute = (model, attributeName) => {
   if (model?.attributes?.[attributeName]?.private === true) {
@@ -13066,49 +13064,49 @@ const isPrivateAttribute = (model, attributeName) => {
   return getStoredPrivateAttributes(model).includes(attributeName);
 };
 const isScalarAttribute = (attribute) => {
-  return attribute && !["media", "component", "relation", "dynamiczone"].includes(attribute.type);
+  return attribute && ![
+    "media",
+    "component",
+    "relation",
+    "dynamiczone"
+  ].includes(attribute.type);
 };
 const getDoesAttributeRequireValidation = (attribute) => {
   return attribute.required || attribute.unique || Object.prototype.hasOwnProperty.call(attribute, "max") || Object.prototype.hasOwnProperty.call(attribute, "min") || Object.prototype.hasOwnProperty.call(attribute, "maxLength") || Object.prototype.hasOwnProperty.call(attribute, "minLength");
 };
 const isMediaAttribute = (attribute) => attribute?.type === "media";
 const isRelationalAttribute = (attribute) => attribute?.type === "relation";
-const HAS_RELATION_REORDERING = ["manyToMany", "manyToOne", "oneToMany"];
+const HAS_RELATION_REORDERING = [
+  "manyToMany",
+  "manyToOne",
+  "oneToMany"
+];
 const hasRelationReordering = (attribute) => isRelationalAttribute(attribute) && HAS_RELATION_REORDERING.includes(attribute.relation);
-const isComponentAttribute = (attribute) => ["component", "dynamiczone"].includes(attribute?.type);
+const isComponentAttribute = (attribute) => [
+  "component",
+  "dynamiczone"
+].includes(attribute?.type);
 const isDynamicZoneAttribute = (attribute) => !!attribute && attribute.type === "dynamiczone";
 const isMorphToRelationalAttribute = (attribute) => {
   return !!attribute && isRelationalAttribute(attribute) && attribute.relation?.startsWith?.("morphTo");
 };
 const getComponentAttributes = (schema2) => {
-  return ___default__default.default.reduce(
-    schema2.attributes,
-    (acc, attr, attrName) => {
-      if (isComponentAttribute(attr)) acc.push(attrName);
-      return acc;
-    },
-    []
-  );
+  return ___default__default.default.reduce(schema2.attributes, (acc, attr, attrName) => {
+    if (isComponentAttribute(attr)) acc.push(attrName);
+    return acc;
+  }, []);
 };
 const getScalarAttributes = (schema2) => {
-  return ___default__default.default.reduce(
-    schema2.attributes,
-    (acc, attr, attrName) => {
-      if (isScalarAttribute(attr)) acc.push(attrName);
-      return acc;
-    },
-    []
-  );
+  return ___default__default.default.reduce(schema2.attributes, (acc, attr, attrName) => {
+    if (isScalarAttribute(attr)) acc.push(attrName);
+    return acc;
+  }, []);
 };
 const getRelationalAttributes = (schema2) => {
-  return ___default__default.default.reduce(
-    schema2.attributes,
-    (acc, attr, attrName) => {
-      if (isRelationalAttribute(attr)) acc.push(attrName);
-      return acc;
-    },
-    []
-  );
+  return ___default__default.default.reduce(schema2.attributes, (acc, attr, attrName) => {
+    if (isRelationalAttribute(attr)) acc.push(attrName);
+    return acc;
+  }, []);
 };
 const isTypedAttribute = (attribute, type2) => {
   return ___default__default.default.has(attribute, "type") && attribute.type === type2;
@@ -13116,7 +13114,7 @@ const isTypedAttribute = (attribute, type2) => {
 const getContentTypeRoutePrefix = (contentType) => {
   return isSingleType(contentType) ? ___default__default.default.kebabCase(contentType.info.singularName) : ___default__default.default.kebabCase(contentType.info.pluralName);
 };
-const contentTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+var contentTypes = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   constants: constants$1,
   getComponentAttributes,
@@ -13151,44 +13149,76 @@ const contentTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.define
   isTypedAttribute,
   isVisibleAttribute,
   isWritableAttribute
-}, Symbol.toStringTag, { value: "Module" }));
-const traverseEntity = async (visitor2, options, entity) => {
-  const { path: path2 = { raw: null, attribute: null }, schema: schema2, getModel } = options;
+});
+const traverseEntity = async (visitor, options, entity) => {
+  const { path: path2 = {
+    raw: null,
+    attribute: null
+  }, schema: schema2, getModel } = options;
   let parent = options.parent;
-  const traverseMorphRelationTarget = async (visitor22, path22, entry) => {
+  const traverseMorphRelationTarget = async (visitor2, path3, entry) => {
     const targetSchema = getModel(entry.__type);
-    const traverseOptions = { schema: targetSchema, path: path22, getModel, parent };
-    return traverseEntity(visitor22, traverseOptions, entry);
+    const traverseOptions = {
+      schema: targetSchema,
+      path: path3,
+      getModel,
+      parent
+    };
+    return traverseEntity(visitor2, traverseOptions, entry);
   };
-  const traverseRelationTarget = (schema22) => async (visitor22, path22, entry) => {
-    const traverseOptions = { schema: schema22, path: path22, getModel, parent };
-    return traverseEntity(visitor22, traverseOptions, entry);
+  const traverseRelationTarget = (schema3) => async (visitor2, path3, entry) => {
+    const traverseOptions = {
+      schema: schema3,
+      path: path3,
+      getModel,
+      parent
+    };
+    return traverseEntity(visitor2, traverseOptions, entry);
   };
-  const traverseMediaTarget = async (visitor22, path22, entry) => {
+  const traverseMediaTarget = async (visitor2, path3, entry) => {
     const targetSchemaUID = "plugin::upload.file";
     const targetSchema = getModel(targetSchemaUID);
-    const traverseOptions = { schema: targetSchema, path: path22, getModel, parent };
-    return traverseEntity(visitor22, traverseOptions, entry);
+    const traverseOptions = {
+      schema: targetSchema,
+      path: path3,
+      getModel,
+      parent
+    };
+    return traverseEntity(visitor2, traverseOptions, entry);
   };
-  const traverseComponent = async (visitor22, path22, schema22, entry) => {
-    const traverseOptions = { schema: schema22, path: path22, getModel, parent };
-    return traverseEntity(visitor22, traverseOptions, entry);
+  const traverseComponent = async (visitor2, path3, schema3, entry) => {
+    const traverseOptions = {
+      schema: schema3,
+      path: path3,
+      getModel,
+      parent
+    };
+    return traverseEntity(visitor2, traverseOptions, entry);
   };
-  const visitDynamicZoneEntry = async (visitor22, path22, entry) => {
+  const visitDynamicZoneEntry = async (visitor2, path3, entry) => {
     const targetSchema = getModel(entry.__component);
-    const traverseOptions = { schema: targetSchema, path: path22, getModel, parent };
-    return traverseEntity(visitor22, traverseOptions, entry);
+    const traverseOptions = {
+      schema: targetSchema,
+      path: path3,
+      getModel,
+      parent
+    };
+    return traverseEntity(visitor2, traverseOptions, entry);
   };
   if (!fp.isObject(entity) || fp.isNil(schema2)) {
     return entity;
   }
   const copy = fp.clone(entity);
-  const visitorUtils = createVisitorUtils({ data: copy });
+  const visitorUtils = createVisitorUtils({
+    data: copy
+  });
   const keys = Object.keys(copy);
   for (let i = 0; i < keys.length; i += 1) {
     const key = keys[i];
     const attribute = schema2.attributes[key];
-    const newPath = { ...path2 };
+    const newPath = {
+      ...path2
+    };
     newPath.raw = fp.isNil(path2.raw) ? key : `${path2.raw}.${key}`;
     if (!fp.isNil(attribute)) {
       newPath.attribute = fp.isNil(path2.attribute) ? key : `${path2.attribute}.${key}`;
@@ -13203,23 +13233,28 @@ const traverseEntity = async (visitor2, options, entity) => {
       getModel,
       parent
     };
-    await visitor2(visitorOptions, visitorUtils);
+    await visitor(visitorOptions, visitorUtils);
     const value = copy[key];
     if (fp.isNil(value) || fp.isNil(attribute)) {
       continue;
     }
-    parent = { schema: schema2, key, attribute, path: newPath };
+    parent = {
+      schema: schema2,
+      key,
+      attribute,
+      path: newPath
+    };
     if (isRelationalAttribute(attribute)) {
       const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
       const method = isMorphRelation ? traverseMorphRelationTarget : traverseRelationTarget(getModel(attribute.target));
       if (fp.isArray(value)) {
         const res = new Array(value.length);
         for (let i2 = 0; i2 < value.length; i2 += 1) {
-          res[i2] = await method(visitor2, newPath, value[i2]);
+          res[i2] = await method(visitor, newPath, value[i2]);
         }
         copy[key] = res;
       } else {
-        copy[key] = await method(visitor2, newPath, value);
+        copy[key] = await method(visitor, newPath, value);
       }
       continue;
     }
@@ -13227,11 +13262,11 @@ const traverseEntity = async (visitor2, options, entity) => {
       if (fp.isArray(value)) {
         const res = new Array(value.length);
         for (let i2 = 0; i2 < value.length; i2 += 1) {
-          res[i2] = await traverseMediaTarget(visitor2, newPath, value[i2]);
+          res[i2] = await traverseMediaTarget(visitor, newPath, value[i2]);
         }
         copy[key] = res;
       } else {
-        copy[key] = await traverseMediaTarget(visitor2, newPath, value);
+        copy[key] = await traverseMediaTarget(visitor, newPath, value);
       }
       continue;
     }
@@ -13240,18 +13275,18 @@ const traverseEntity = async (visitor2, options, entity) => {
       if (fp.isArray(value)) {
         const res = new Array(value.length);
         for (let i2 = 0; i2 < value.length; i2 += 1) {
-          res[i2] = await traverseComponent(visitor2, newPath, targetSchema, value[i2]);
+          res[i2] = await traverseComponent(visitor, newPath, targetSchema, value[i2]);
         }
         copy[key] = res;
       } else {
-        copy[key] = await traverseComponent(visitor2, newPath, targetSchema, value);
+        copy[key] = await traverseComponent(visitor, newPath, targetSchema, value);
       }
       continue;
     }
     if (attribute.type === "dynamiczone" && fp.isArray(value)) {
       const res = new Array(value.length);
       for (let i2 = 0; i2 < value.length; i2 += 1) {
-        res[i2] = await visitDynamicZoneEntry(visitor2, newPath, value[i2]);
+        res[i2] = await visitDynamicZoneEntry(visitor, newPath, value[i2]);
       }
       copy[key] = res;
       continue;
@@ -13267,8 +13302,11 @@ const createVisitorUtils = ({ data }) => ({
     data[key] = value;
   }
 });
-const traverseEntity$1 = fp.curry(traverseEntity);
-const GROUP_OPERATORS = ["$and", "$or"];
+var traverseEntity$1 = fp.curry(traverseEntity);
+const GROUP_OPERATORS = [
+  "$and",
+  "$or"
+];
 const WHERE_OPERATORS = [
   "$not",
   "$in",
@@ -13307,19 +13345,21 @@ const CAST_OPERATORS = [
   "$lte",
   "$between"
 ];
-const ARRAY_OPERATORS = ["$in", "$notIn", "$between"];
+const ARRAY_OPERATORS = [
+  "$in",
+  "$notIn",
+  "$between"
+];
 const OPERATORS = {
   where: WHERE_OPERATORS,
   cast: CAST_OPERATORS,
   group: GROUP_OPERATORS,
   array: ARRAY_OPERATORS
 };
-const OPERATORS_LOWERCASE = Object.fromEntries(
-  Object.entries(OPERATORS).map(([key, values]) => [
-    key,
-    values.map((value) => value.toLowerCase())
-  ])
-);
+const OPERATORS_LOWERCASE = Object.fromEntries(Object.entries(OPERATORS).map(([key, values]) => [
+  key,
+  values.map((value) => value.toLowerCase())
+]));
 const isObjKey = (key, obj) => {
   return key in obj;
 };
@@ -13346,26 +13386,28 @@ function pipe(...fns) {
   };
 }
 fp.curry(pMap$1);
-const visitor$8 = ({ key, attribute }, { remove: remove2 }) => {
+const visitor$8 = ({ key, attribute }, { remove }) => {
   if (attribute?.type === "password") {
-    remove2(key);
+    remove(key);
   }
 };
-const visitor$7 = ({ schema: schema2, key, attribute }, { remove: remove2 }) => {
+const visitor$7 = ({ schema: schema2, key, attribute }, { remove }) => {
   if (!attribute) {
     return;
   }
   const isPrivate = attribute.private === true || isPrivateAttribute(schema2, key);
   if (isPrivate) {
-    remove2(key);
+    remove(key);
   }
 };
 const VALID_RELATION_ORDERING_KEYS = {
   strict: fp.isBoolean
 };
-const ACTIONS_TO_VERIFY$1 = ["find"];
+const ACTIONS_TO_VERIFY$1 = [
+  "find"
+];
 const { CREATED_BY_ATTRIBUTE: CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE: UPDATED_BY_ATTRIBUTE$1 } = constants$1;
-const removeRestrictedRelations = (auth) => async ({ data, key, attribute, schema: schema2 }, { remove: remove2, set: set2 }) => {
+var removeRestrictedRelations = (auth) => async ({ data, key, attribute, schema: schema2 }, { remove, set: set2 }) => {
   if (!attribute) {
     return;
   }
@@ -13430,10 +13472,13 @@ const removeRestrictedRelations = (auth) => async ({ data, key, attribute, schem
     const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${attribute.target}.${action}`);
     const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
     if (!isAllowed) {
-      remove2(key);
+      remove(key);
     }
   };
-  const isCreatorRelation = [CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE$1].includes(key);
+  const isCreatorRelation = [
+    CREATED_BY_ATTRIBUTE$1,
+    UPDATED_BY_ATTRIBUTE$1
+  ].includes(key);
   if (isMorphToRelationalAttribute(attribute)) {
     await handleMorphRelation();
     return;
@@ -13446,7 +13491,9 @@ const removeRestrictedRelations = (auth) => async ({ data, key, attribute, schem
 const hasAccessToSomeScopes$1 = async (scopes, auth) => {
   for (const scope of scopes) {
     try {
-      await strapi.auth.verify(auth, { scope });
+      await strapi.auth.verify(auth, {
+        scope
+      });
       return true;
     } catch {
       continue;
@@ -13454,74 +13501,75 @@ const hasAccessToSomeScopes$1 = async (scopes, auth) => {
   }
   return false;
 };
-const visitor$6 = ({ key, attribute }, { remove: remove2 }) => {
+const visitor$6 = ({ key, attribute }, { remove }) => {
   if (isMorphToRelationalAttribute(attribute)) {
-    remove2(key);
+    remove(key);
   }
 };
-const visitor$5 = ({ key, attribute }, { remove: remove2 }) => {
+const visitor$5 = ({ key, attribute }, { remove }) => {
   if (isDynamicZoneAttribute(attribute)) {
-    remove2(key);
+    remove(key);
   }
 };
-const removeDisallowedFields = (allowedFields = null) => ({ key, path: { attribute: path2 } }, { remove: remove2 }) => {
+var removeDisallowedFields = (allowedFields = null) => ({ key, path: { attribute: path2 } }, { remove }) => {
   if (allowedFields === null) {
     return;
   }
   if (!(fp.isArray(allowedFields) && allowedFields.every(fp.isString))) {
-    throw new TypeError(
-      `Expected array of strings for allowedFields but got "${typeof allowedFields}"`
-    );
+    throw new TypeError(`Expected array of strings for allowedFields but got "${typeof allowedFields}"`);
   }
   if (fp.isNil(path2)) {
     return;
   }
   const containedPaths = getContainedPaths$1(path2);
-  const isPathAllowed = allowedFields.some(
-    (p) => containedPaths.includes(p) || p.startsWith(`${path2}.`)
-  );
+  const isPathAllowed = allowedFields.some((p) => containedPaths.includes(p) || p.startsWith(`${path2}.`));
   if (isPathAllowed) {
     return;
   }
-  remove2(key);
+  remove(key);
 };
 const getContainedPaths$1 = (path2) => {
   const parts = fp.toPath(path2);
   return parts.reduce((acc, value, index2, list) => {
-    return [...acc, list.slice(0, index2 + 1).join(".")];
+    return [
+      ...acc,
+      list.slice(0, index2 + 1).join(".")
+    ];
   }, []);
 };
-const removeRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path2 } }, { remove: remove2 }) => {
+var removeRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path2 } }, { remove }) => {
   if (restrictedFields === null) {
-    remove2(key);
+    remove(key);
     return;
   }
   if (!(fp.isArray(restrictedFields) && restrictedFields.every(fp.isString))) {
-    throw new TypeError(
-      `Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`
-    );
+    throw new TypeError(`Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`);
   }
   if (restrictedFields.includes(path2)) {
-    remove2(key);
+    remove(key);
     return;
   }
-  const isRestrictedNested = restrictedFields.some(
-    (allowedPath) => path2?.toString().startsWith(`${allowedPath}.`)
-  );
+  const isRestrictedNested = restrictedFields.some((allowedPath) => path2?.toString().startsWith(`${allowedPath}.`));
   if (isRestrictedNested) {
-    remove2(key);
+    remove(key);
   }
 };
 const visitor$4 = ({ schema: schema2, key, value }, { set: set2 }) => {
   if (key === "" && value === "*") {
     const { attributes } = schema2;
-    const newPopulateQuery = Object.entries(attributes).filter(
-      ([, attribute]) => ["relation", "component", "media", "dynamiczone"].includes(attribute.type)
-    ).reduce((acc, [key2]) => ({ ...acc, [key2]: true }), {});
+    const newPopulateQuery = Object.entries(attributes).filter(([, attribute]) => [
+      "relation",
+      "component",
+      "media",
+      "dynamiczone"
+    ].includes(attribute.type)).reduce((acc, [key2]) => ({
+      ...acc,
+      [key2]: true
+    }), {});
     set2("", newPopulateQuery);
   }
 };
-const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+var index$4 = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   expandWildcardPopulate: visitor$4,
   removeDisallowedFields,
@@ -13531,9 +13579,12 @@ const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   removePrivate: visitor$7,
   removeRestrictedFields,
   removeRestrictedRelations
-}, Symbol.toStringTag, { value: "Module" }));
-const DEFAULT_PATH = { raw: null, attribute: null };
-const traverseFactory = () => {
+});
+const DEFAULT_PATH = {
+  raw: null,
+  attribute: null
+};
+var traverseFactory = () => {
   const state = {
     parsers: [],
     interceptors: [],
@@ -13543,11 +13594,13 @@ const traverseFactory = () => {
       common: []
     }
   };
-  const traverse = async (visitor2, options, data) => {
+  const traverse = async (visitor, options, data) => {
     const { path: path2 = DEFAULT_PATH, parent, schema: schema2, getModel } = options ?? {};
     for (const { predicate, handler } of state.interceptors) {
       if (predicate(data)) {
-        return handler(visitor2, options, data, { recurse: traverse });
+        return handler(visitor, options, data, {
+          recurse: traverse
+        });
       }
     }
     const parser = state.parsers.find((parser2) => parser2.predicate(data))?.parser;
@@ -13559,7 +13612,9 @@ const traverseFactory = () => {
     const keys = utils2.keys(out);
     for (const key of keys) {
       const attribute = schema2?.attributes?.[key];
-      const newPath = { ...path2 };
+      const newPath = {
+        ...path2
+      };
       newPath.raw = fp.isNil(path2.raw) ? key : `${path2.raw}.${key}`;
       if (!fp.isNil(attribute)) {
         newPath.attribute = fp.isNil(path2.attribute) ? key : `${path2.attribute}.${key}`;
@@ -13583,7 +13638,10 @@ const traverseFactory = () => {
         },
         recurse: traverse
       };
-      await visitor2(visitorOptions, fp.pick(["remove", "set"], transformUtils));
+      await visitor(visitorOptions, fp.pick([
+        "remove",
+        "set"
+      ], transformUtils));
       const value = utils2.get(key, out);
       const createContext = () => ({
         key,
@@ -13592,7 +13650,7 @@ const traverseFactory = () => {
         schema: schema2,
         path: newPath,
         data: out,
-        visitor: visitor2,
+        visitor,
         getModel,
         parent
       });
@@ -13601,12 +13659,18 @@ const traverseFactory = () => {
       if (shouldIgnore) {
         continue;
       }
-      const handlers = [...state.handlers.common, ...state.handlers.attributes];
+      const handlers = [
+        ...state.handlers.common,
+        ...state.handlers.attributes
+      ];
       for await (const handler of handlers) {
         const ctx = createContext();
         const pass = await handler.predicate(ctx);
         if (pass) {
-          await handler.handler(ctx, fp.pick(["recurse", "set"], transformUtils));
+          await handler.handler(ctx, fp.pick([
+            "recurse",
+            "set"
+          ], transformUtils));
         }
       }
     }
@@ -13615,11 +13679,17 @@ const traverseFactory = () => {
   return {
     traverse,
     intercept(predicate, handler) {
-      state.interceptors.push({ predicate, handler });
+      state.interceptors.push({
+        predicate,
+        handler
+      });
       return this;
     },
     parse(predicate, parser) {
-      state.parsers.push({ predicate, parser });
+      state.parsers.push({
+        predicate,
+        parser
+      });
       return this;
     },
     ignore(predicate) {
@@ -13627,11 +13697,17 @@ const traverseFactory = () => {
       return this;
     },
     on(predicate, handler) {
-      state.handlers.common.push({ predicate, handler });
+      state.handlers.common.push({
+        predicate,
+        handler
+      });
       return this;
     },
     onAttribute(predicate, handler) {
-      state.handlers.attributes.push({ predicate, handler });
+      state.handlers.attributes.push({
+        predicate,
+        handler
+      });
       return this;
     },
     onRelation(handler) {
@@ -13652,19 +13728,22 @@ const isObj$2 = (value) => fp.isObject(value);
 const filters = traverseFactory().intercept(
   // Intercept filters arrays and apply the traversal to each one individually
   fp.isArray,
-  async (visitor2, options, filters2, { recurse }) => {
-    return Promise.all(
-      filters2.map((filter, i) => {
-        const newPath = options.path ? { ...options.path, raw: `${options.path.raw}[${i}]` } : options.path;
-        return recurse(visitor2, { ...options, path: newPath }, filter);
-      })
-      // todo: move that to the visitors
-    ).then((res) => res.filter((val) => !(fp.isObject(val) && fp.isEmpty(val))));
+  async (visitor, options, filters2, { recurse }) => {
+    return Promise.all(filters2.map((filter, i) => {
+      const newPath = options.path ? {
+        ...options.path,
+        raw: `${options.path.raw}[${i}]`
+      } : options.path;
+      return recurse(visitor, {
+        ...options,
+        path: newPath
+      }, filter);
+    })).then((res) => res.filter((val) => !(fp.isObject(val) && fp.isEmpty(val))));
   }
 ).intercept(
   // Ignore non object filters and return the value as-is
   (filters2) => !fp.isObject(filters2),
-  (_2, __, filters2) => {
+  (_, __, filters2) => {
     return filters2;
   }
 ).parse(isObj$2, () => ({
@@ -13673,7 +13752,10 @@ const filters = traverseFactory().intercept(
     return fp.omit(key, data);
   },
   set(key, value, data) {
-    return { ...data, [key]: value };
+    return {
+      ...data,
+      [key]: value
+    };
   },
   keys(data) {
     return Object.keys(data);
@@ -13681,52 +13763,76 @@ const filters = traverseFactory().intercept(
   get(key, data) {
     return data[key];
   }
-})).ignore(({ value }) => fp.isNil(value)).on(
-  ({ attribute }) => fp.isNil(attribute),
-  async ({ key, visitor: visitor2, path: path2, value, schema: schema2, getModel, attribute }, { set: set2, recurse }) => {
-    const parent = { key, path: path2, schema: schema2, attribute };
-    set2(key, await recurse(visitor2, { schema: schema2, path: path2, getModel, parent }, value));
-  }
-).onRelation(
-  async ({ key, attribute, visitor: visitor2, path: path2, value, schema: schema2, getModel }, { set: set2, recurse }) => {
-    const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
-    if (isMorphRelation) {
-      return;
-    }
-    const parent = { key, path: path2, schema: schema2, attribute };
-    const targetSchemaUID = attribute.target;
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(
-      visitor2,
-      { schema: targetSchema, path: path2, getModel, parent },
-      value
-    );
-    set2(key, newValue);
-  }
-).onComponent(
-  async ({ key, attribute, visitor: visitor2, path: path2, schema: schema2, value, getModel }, { set: set2, recurse }) => {
-    const parent = { key, path: path2, schema: schema2, attribute };
-    const targetSchema = getModel(attribute.component);
-    const newValue = await recurse(
-      visitor2,
-      { schema: targetSchema, path: path2, getModel, parent },
-      value
-    );
-    set2(key, newValue);
+})).ignore(({ value }) => fp.isNil(value)).on(({ attribute }) => fp.isNil(attribute), async ({ key, visitor, path: path2, value, schema: schema2, getModel, attribute }, { set: set2, recurse }) => {
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
+  set2(key, await recurse(visitor, {
+    schema: schema2,
+    path: path2,
+    getModel,
+    parent
+  }, value));
+}).onRelation(async ({ key, attribute, visitor, path: path2, value, schema: schema2, getModel }, { set: set2, recurse }) => {
+  const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
+  if (isMorphRelation) {
+    return;
   }
-).onMedia(async ({ key, visitor: visitor2, path: path2, schema: schema2, attribute, value, getModel }, { set: set2, recurse }) => {
-  const parent = { key, path: path2, schema: schema2, attribute };
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
+  const targetSchemaUID = attribute.target;
+  const targetSchema = getModel(targetSchemaUID);
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
+  set2(key, newValue);
+}).onComponent(async ({ key, attribute, visitor, path: path2, schema: schema2, value, getModel }, { set: set2, recurse }) => {
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
+  const targetSchema = getModel(attribute.component);
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
+  set2(key, newValue);
+}).onMedia(async ({ key, visitor, path: path2, schema: schema2, attribute, value, getModel }, { set: set2, recurse }) => {
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = getModel(targetSchemaUID);
-  const newValue = await recurse(
-    visitor2,
-    { schema: targetSchema, path: path2, getModel, parent },
-    value
-  );
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
   set2(key, newValue);
 });
-const traverseQueryFilters = fp.curry(filters.traverse);
-const ORDERS = { asc: "asc", desc: "desc" };
+var traverseQueryFilters = fp.curry(filters.traverse);
+const ORDERS = {
+  asc: "asc",
+  desc: "desc"
+};
 const ORDER_VALUES = Object.values(ORDERS);
 const isSortOrder = (value) => ORDER_VALUES.includes(value.toLowerCase());
 const isStringArray$2 = (value) => Array.isArray(value) && value.every(fp.isString);
@@ -13736,26 +13842,20 @@ const isObj$1 = (value) => fp.isObject(value);
 const sort = traverseFactory().intercept(
   // String with chained sorts (foo,bar,foobar) => split, map(recurse), then recompose
   isNestedSorts,
-  async (visitor2, options, sort2, { recurse }) => {
-    return Promise.all(
-      sort2.split(",").map(fp.trim).map((nestedSort) => recurse(visitor2, options, nestedSort))
-    ).then((res) => res.filter((part) => !fp.isEmpty(part)).join(","));
+  async (visitor, options, sort2, { recurse }) => {
+    return Promise.all(sort2.split(",").map(fp.trim).map((nestedSort) => recurse(visitor, options, nestedSort))).then((res) => res.filter((part) => !fp.isEmpty(part)).join(","));
   }
 ).intercept(
   // Array of strings ['foo', 'foo,bar'] => map(recurse), then filter out empty items
   isStringArray$2,
-  async (visitor2, options, sort2, { recurse }) => {
-    return Promise.all(sort2.map((nestedSort) => recurse(visitor2, options, nestedSort))).then(
-      (res) => res.filter((nestedSort) => !fp.isEmpty(nestedSort))
-    );
+  async (visitor, options, sort2, { recurse }) => {
+    return Promise.all(sort2.map((nestedSort) => recurse(visitor, options, nestedSort))).then((res) => res.filter((nestedSort) => !fp.isEmpty(nestedSort)));
   }
 ).intercept(
   // Array of objects [{ foo: 'asc' }, { bar: 'desc', baz: 'asc' }] => map(recurse), then filter out empty items
   isObjectArray,
-  async (visitor2, options, sort2, { recurse }) => {
-    return Promise.all(sort2.map((nestedSort) => recurse(visitor2, options, nestedSort))).then(
-      (res) => res.filter((nestedSort) => !fp.isEmpty(nestedSort))
-    );
+  async (visitor, options, sort2, { recurse }) => {
+    return Promise.all(sort2.map((nestedSort) => recurse(visitor, options, nestedSort))).then((res) => res.filter((nestedSort) => !fp.isEmpty(nestedSort)));
   }
 ).parse(fp.isString, () => {
   const tokenize = fp.pipe(fp.split("."), fp.map(fp.split(":")), fp.flatten);
@@ -13788,7 +13888,9 @@ const sort = traverseFactory().intercept(
     },
     keys(data) {
       const v = fp.first(tokenize(data));
-      return v ? [v] : [];
+      return v ? [
+        v
+      ] : [];
     },
     get(key, data) {
       const [root2, ...rest] = tokenize(data);
@@ -13802,7 +13904,10 @@ const sort = traverseFactory().intercept(
     return rest;
   },
   set(key, value, data) {
-    return { ...data, [key]: value };
+    return {
+      ...data,
+      [key]: value
+    };
   },
   keys(data) {
     return Object.keys(data);
@@ -13810,45 +13915,59 @@ const sort = traverseFactory().intercept(
   get(key, data) {
     return data[key];
   }
-})).onRelation(
-  async ({ key, value, attribute, visitor: visitor2, path: path2, getModel, schema: schema2 }, { set: set2, recurse }) => {
-    const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
-    if (isMorphRelation) {
-      return;
-    }
-    const parent = { key, path: path2, schema: schema2, attribute };
-    const targetSchemaUID = attribute.target;
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(
-      visitor2,
-      { schema: targetSchema, path: path2, getModel, parent },
-      value
-    );
-    set2(key, newValue);
+})).onRelation(async ({ key, value, attribute, visitor, path: path2, getModel, schema: schema2 }, { set: set2, recurse }) => {
+  const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
+  if (isMorphRelation) {
+    return;
   }
-).onMedia(async ({ key, path: path2, schema: schema2, attribute, visitor: visitor2, value, getModel }, { recurse, set: set2 }) => {
-  const parent = { key, path: path2, schema: schema2, attribute };
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
+  const targetSchemaUID = attribute.target;
+  const targetSchema = getModel(targetSchemaUID);
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
+  set2(key, newValue);
+}).onMedia(async ({ key, path: path2, schema: schema2, attribute, visitor, value, getModel }, { recurse, set: set2 }) => {
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = getModel(targetSchemaUID);
-  const newValue = await recurse(
-    visitor2,
-    { schema: targetSchema, path: path2, getModel, parent },
-    value
-  );
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
   set2(key, newValue);
-}).onComponent(
-  async ({ key, value, visitor: visitor2, path: path2, schema: schema2, attribute, getModel }, { recurse, set: set2 }) => {
-    const parent = { key, path: path2, schema: schema2, attribute };
-    const targetSchema = getModel(attribute.component);
-    const newValue = await recurse(
-      visitor2,
-      { schema: targetSchema, path: path2, getModel, parent },
-      value
-    );
-    set2(key, newValue);
-  }
-);
-const traverseQuerySort = fp.curry(sort.traverse);
+}).onComponent(async ({ key, value, visitor, path: path2, schema: schema2, attribute, getModel }, { recurse, set: set2 }) => {
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
+  const targetSchema = getModel(attribute.component);
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
+  set2(key, newValue);
+});
+var traverseQuerySort = fp.curry(sort.traverse);
 const isKeyword = (keyword) => {
   return ({ key, attribute }) => {
     return !attribute && keyword === key;
@@ -13860,39 +13979,41 @@ const isPopulateString = (value) => {
 };
 const isStringArray$1 = (value) => fp.isArray(value) && value.every(fp.isString);
 const isObj = (value) => fp.isObject(value);
-const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2, options, populate2, { recurse }) => {
-  const populateObject = pathsToObjectPopulate([populate2]);
-  const traversedPopulate = await recurse(visitor2, options, populateObject);
+const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor, options, populate2, { recurse }) => {
+  const populateObject = pathsToObjectPopulate([
+    populate2
+  ]);
+  const traversedPopulate = await recurse(visitor, 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))
-  );
+}).intercept(isStringArray$1, async (visitor, options, populate2, { recurse }) => {
+  const paths = await Promise.all(populate2.map((subClause) => recurse(visitor, options, subClause)));
   return paths.filter((item) => !fp.isNil(item));
 }).parse(isWildcard, () => ({
   /**
-   * Since value is '*', we don't need to transform it
-   */
+  * 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 ('*')
-   */
+  * '*' 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`
-   */
+  * '*' 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([""]),
+  * '*' 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
-   */
+  * Removing '*' means setting it to undefined, regardless of the given key
+  */
   remove: fp.constant(void 0)
 })).parse(fp.isString, () => {
   const tokenize = fp.split(".");
@@ -13912,7 +14033,9 @@ const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2
     },
     keys(data) {
       const v = fp.first(tokenize(data));
-      return v ? [v] : [];
+      return v ? [
+        v
+      ] : [];
     },
     get(key, data) {
       const [root2, ...rest] = tokenize(data);
@@ -13926,7 +14049,10 @@ const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2
     return rest;
   },
   set(key, value, data) {
-    return { ...data, [key]: value };
+    return {
+      ...data,
+      [key]: value
+    };
   },
   keys(data) {
     return Object.keys(data);
@@ -13935,100 +14061,142 @@ const populate$2 = traverseFactory().intercept(isPopulateString, async (visitor2
     return data[key];
   }
 })).ignore(({ key, attribute }) => {
-  return ["sort", "filters", "fields"].includes(key) && !attribute;
+  return [
+    "sort",
+    "filters",
+    "fields"
+  ].includes(key) && !attribute;
 }).on(
   // Handle recursion on populate."populate"
   isKeyword("populate"),
-  async ({ key, visitor: visitor2, path: path2, value, schema: schema2, getModel, attribute }, { set: set2, recurse }) => {
-    const parent = { key, path: path2, schema: schema2, attribute };
-    const newValue = await recurse(visitor2, { schema: schema2, path: path2, getModel, parent }, value);
+  async ({ key, visitor, path: path2, value, schema: schema2, getModel, attribute }, { set: set2, recurse }) => {
+    const parent = {
+      key,
+      path: path2,
+      schema: schema2,
+      attribute
+    };
+    const newValue = await recurse(visitor, {
+      schema: schema2,
+      path: path2,
+      getModel,
+      parent
+    }, value);
     set2(key, newValue);
   }
-).on(
-  isKeyword("on"),
-  async ({ key, visitor: visitor2, path: path2, value, getModel, parent }, { set: set2, recurse }) => {
-    const newOn = {};
-    if (!isObj(value)) {
-      return;
-    }
-    for (const [uid, subPopulate] of Object.entries(value)) {
-      const model = getModel(uid);
-      const newPath = { ...path2, raw: `${path2.raw}[${uid}]` };
-      newOn[uid] = await recurse(
-        visitor2,
-        { schema: model, path: newPath, getModel, parent },
-        subPopulate
-      );
-    }
-    set2(key, newOn);
+).on(isKeyword("on"), async ({ key, visitor, path: path2, value, getModel, parent }, { set: set2, recurse }) => {
+  const newOn = {};
+  if (!isObj(value)) {
+    return;
   }
-).onRelation(
-  async ({ key, value, attribute, visitor: visitor2, path: path2, schema: schema2, getModel }, { set: set2, recurse }) => {
-    if (fp.isNil(value)) {
-      return;
-    }
-    const parent = { key, path: path2, schema: schema2, attribute };
-    if (isMorphToRelationalAttribute(attribute)) {
-      if (!fp.isObject(value) || !("on" in value && fp.isObject(value?.on))) {
-        return;
-      }
-      const newValue2 = await recurse(
-        visitor2,
-        { schema: schema2, path: path2, getModel, parent },
-        { on: value?.on }
-      );
-      set2(key, newValue2);
+  for (const [uid, subPopulate] of Object.entries(value)) {
+    const model = getModel(uid);
+    const newPath = {
+      ...path2,
+      raw: `${path2.raw}[${uid}]`
+    };
+    newOn[uid] = await recurse(visitor, {
+      schema: model,
+      path: newPath,
+      getModel,
+      parent
+    }, subPopulate);
+  }
+  set2(key, newOn);
+}).onRelation(async ({ key, value, attribute, visitor, path: path2, schema: schema2, getModel }, { set: set2, recurse }) => {
+  if (fp.isNil(value)) {
+    return;
+  }
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
+  if (isMorphToRelationalAttribute(attribute)) {
+    if (!fp.isObject(value) || !("on" in value && fp.isObject(value?.on))) {
       return;
     }
-    const targetSchemaUID = attribute.target;
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(
-      visitor2,
-      { schema: targetSchema, path: path2, getModel, parent },
-      value
-    );
-    set2(key, newValue);
+    const newValue2 = await recurse(visitor, {
+      schema: schema2,
+      path: path2,
+      getModel,
+      parent
+    }, {
+      on: value?.on
+    });
+    set2(key, newValue2);
+    return;
   }
-).onMedia(async ({ key, path: path2, schema: schema2, attribute, visitor: visitor2, value, getModel }, { recurse, set: set2 }) => {
+  const targetSchemaUID = attribute.target;
+  const targetSchema = getModel(targetSchemaUID);
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
+  set2(key, newValue);
+}).onMedia(async ({ key, path: path2, schema: schema2, attribute, visitor, value, getModel }, { recurse, set: set2 }) => {
   if (fp.isNil(value)) {
     return;
   }
-  const parent = { key, path: path2, schema: schema2, attribute };
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = getModel(targetSchemaUID);
-  const newValue = await recurse(
-    visitor2,
-    { schema: targetSchema, path: path2, getModel, parent },
-    value
-  );
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
   set2(key, newValue);
-}).onComponent(
-  async ({ key, value, schema: schema2, visitor: visitor2, path: path2, attribute, getModel }, { recurse, set: set2 }) => {
-    if (fp.isNil(value)) {
-      return;
-    }
-    const parent = { key, path: path2, schema: schema2, attribute };
-    const targetSchema = getModel(attribute.component);
-    const newValue = await recurse(
-      visitor2,
-      { schema: targetSchema, path: path2, getModel, parent },
-      value
-    );
-    set2(key, newValue);
+}).onComponent(async ({ key, value, schema: schema2, visitor, path: path2, attribute, getModel }, { recurse, set: set2 }) => {
+  if (fp.isNil(value)) {
+    return;
   }
-).onDynamicZone(
-  async ({ key, value, schema: schema2, visitor: visitor2, path: path2, attribute, getModel }, { set: set2, recurse }) => {
-    if (fp.isNil(value) || !fp.isObject(value)) {
-      return;
-    }
-    const parent = { key, path: path2, schema: schema2, attribute };
-    if ("on" in value && value.on) {
-      const newOn = await recurse(visitor2, { schema: schema2, path: path2, getModel, parent }, { on: value.on });
-      set2(key, newOn);
-    }
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
+  const targetSchema = getModel(attribute.component);
+  const newValue = await recurse(visitor, {
+    schema: targetSchema,
+    path: path2,
+    getModel,
+    parent
+  }, value);
+  set2(key, newValue);
+}).onDynamicZone(async ({ key, value, schema: schema2, visitor, path: path2, attribute, getModel }, { set: set2, recurse }) => {
+  if (fp.isNil(value) || !fp.isObject(value)) {
+    return;
   }
-);
-const traverseQueryPopulate = fp.curry(populate$2.traverse);
+  const parent = {
+    key,
+    path: path2,
+    schema: schema2,
+    attribute
+  };
+  if ("on" in value && value.on) {
+    const newOn = await recurse(visitor, {
+      schema: schema2,
+      path: path2,
+      getModel,
+      parent
+    }, {
+      on: value.on
+    });
+    set2(key, newOn);
+  }
+});
+var traverseQueryPopulate = fp.curry(populate$2.traverse);
 const objectPopulateToPaths = (input) => {
   const paths = [];
   function traverse(currentObj, parentPath) {
@@ -14047,14 +14215,16 @@ const objectPopulateToPaths = (input) => {
 const pathsToObjectPopulate = (input) => {
   const result = {};
   function traverse(object2, keys) {
-    const [first2, ...rest] = keys;
+    const [first, ...rest] = keys;
     if (rest.length === 0) {
-      object2[first2] = true;
+      object2[first] = true;
     } else {
-      if (!object2[first2] || typeof object2[first2] === "boolean") {
-        object2[first2] = { populate: {} };
+      if (!object2[first] || typeof object2[first] === "boolean") {
+        object2[first] = {
+          populate: {}
+        };
       }
-      traverse(object2[first2].populate, rest);
+      traverse(object2[first].populate, rest);
     }
   }
   input.forEach((clause) => traverse(result, clause.split(".")));
@@ -14063,14 +14233,11 @@ const pathsToObjectPopulate = (input) => {
 const isStringArray = (value) => {
   return fp.isArray(value) && value.every(fp.isString);
 };
-const fields = traverseFactory().intercept(isStringArray, async (visitor2, options, fields2, { recurse }) => {
-  return Promise.all(fields2.map((field) => recurse(visitor2, options, field)));
-}).intercept(
-  (value) => fp.isString(value) && value.includes(","),
-  (visitor2, options, fields2, { recurse }) => {
-    return Promise.all(fields2.split(",").map((field) => recurse(visitor2, options, field)));
-  }
-).intercept((value) => fp.eq("*", value), fp.constant("*")).parse(fp.isString, () => ({
+const fields = traverseFactory().intercept(isStringArray, async (visitor, options, fields2, { recurse }) => {
+  return Promise.all(fields2.map((field) => recurse(visitor, options, field)));
+}).intercept((value) => fp.isString(value) && value.includes(","), (visitor, options, fields2, { recurse }) => {
+  return Promise.all(fields2.split(",").map((field) => recurse(visitor, options, field)));
+}).intercept((value) => fp.eq("*", value), fp.constant("*")).parse(fp.isString, () => ({
   transform: fp.trim,
   remove(key, data) {
     return data === key ? void 0 : data;
@@ -14079,13 +14246,15 @@ const fields = traverseFactory().intercept(isStringArray, async (visitor2, optio
     return data;
   },
   keys(data) {
-    return [data];
+    return [
+      data
+    ];
   },
   get(key, data) {
     return key === data ? data : void 0;
   }
 }));
-const traverseQueryFields = fp.curry(fields.traverse);
+var traverseQueryFields = fp.curry(fields.traverse);
 const { ID_ATTRIBUTE: ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$2 } = constants$1;
 const sanitizePasswords = (ctx) => async (entity) => {
   if (!ctx.schema) {
@@ -14097,14 +14266,10 @@ const defaultSanitizeOutput = async (ctx, entity) => {
   if (!ctx.schema) {
     throw new Error("Missing schema in defaultSanitizeOutput");
   }
-  return traverseEntity$1(
-    (...args) => {
-      visitor$8(...args);
-      visitor$7(...args);
-    },
-    ctx,
-    entity
-  );
+  return traverseEntity$1((...args) => {
+    visitor$8(...args);
+    visitor$7(...args);
+  }, ctx, entity);
 };
 const defaultSanitizeFilters = fp.curry((ctx, filters2) => {
   if (!ctx.schema) {
@@ -14112,13 +14277,16 @@ const defaultSanitizeFilters = fp.curry((ctx, filters2) => {
   }
   return pipe(
     // Remove keys that are not attributes or valid operators
-    traverseQueryFilters(({ key, attribute }, { remove: remove2 }) => {
+    traverseQueryFilters(({ key, attribute }, { remove }) => {
       const isAttribute = !!attribute;
-      if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
+      if ([
+        ID_ATTRIBUTE$2,
+        DOC_ID_ATTRIBUTE$2
+      ].includes(key)) {
         return;
       }
       if (!isAttribute && !isOperator(key)) {
-        remove2(key);
+        remove(key);
       }
     }, ctx),
     // Remove dynamic zones from filters
@@ -14130,9 +14298,9 @@ const defaultSanitizeFilters = fp.curry((ctx, filters2) => {
     // Remove private from filters
     traverseQueryFilters(visitor$7, ctx),
     // Remove empty objects
-    traverseQueryFilters(({ key, value }, { remove: remove2 }) => {
+    traverseQueryFilters(({ key, value }, { remove }) => {
       if (fp.isObject(value) && fp.isEmpty(value)) {
-        remove2(key);
+        remove(key);
       }
     }, ctx)
   )(filters2);
@@ -14143,12 +14311,15 @@ const defaultSanitizeSort = fp.curry((ctx, sort2) => {
   }
   return pipe(
     // Remove non attribute keys
-    traverseQuerySort(({ key, attribute }, { remove: remove2 }) => {
-      if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
+    traverseQuerySort(({ key, attribute }, { remove }) => {
+      if ([
+        ID_ATTRIBUTE$2,
+        DOC_ID_ATTRIBUTE$2
+      ].includes(key)) {
         return;
       }
       if (!attribute) {
-        remove2(key);
+        remove(key);
       }
     }, ctx),
     // Remove dynamic zones from sort
@@ -14160,12 +14331,15 @@ const defaultSanitizeSort = fp.curry((ctx, sort2) => {
     // Remove passwords from filters
     traverseQuerySort(visitor$8, ctx),
     // Remove keys for empty non-scalar values
-    traverseQuerySort(({ key, attribute, value }, { remove: remove2 }) => {
-      if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
+    traverseQuerySort(({ key, attribute, value }, { remove }) => {
+      if ([
+        ID_ATTRIBUTE$2,
+        DOC_ID_ATTRIBUTE$2
+      ].includes(key)) {
         return;
       }
       if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
-        remove2(key);
+        remove(key);
       }
     }, ctx)
   )(sort2);
@@ -14176,12 +14350,15 @@ const defaultSanitizeFields = fp.curry((ctx, fields2) => {
   }
   return pipe(
     // Only keep scalar attributes
-    traverseQueryFields(({ key, attribute }, { remove: remove2 }) => {
-      if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
+    traverseQueryFields(({ key, attribute }, { remove }) => {
+      if ([
+        ID_ATTRIBUTE$2,
+        DOC_ID_ATTRIBUTE$2
+      ].includes(key)) {
         return;
       }
       if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
-        remove2(key);
+        remove(key);
       }
     }, ctx),
     // Remove private fields
@@ -14202,25 +14379,46 @@ const defaultSanitizePopulate = fp.curry((ctx, populate2) => {
       if (attribute) {
         return;
       }
-      const parent = { key, path: path2, schema: schema2, attribute };
+      const parent = {
+        key,
+        path: path2,
+        schema: schema2,
+        attribute
+      };
       if (key === "sort") {
-        set2(key, await defaultSanitizeSort({ schema: schema2, getModel, parent }, value));
+        set2(key, await defaultSanitizeSort({
+          schema: schema2,
+          getModel,
+          parent
+        }, value));
       }
       if (key === "filters") {
-        set2(key, await defaultSanitizeFilters({ schema: schema2, getModel, parent }, value));
+        set2(key, await defaultSanitizeFilters({
+          schema: schema2,
+          getModel,
+          parent
+        }, value));
       }
       if (key === "fields") {
-        set2(key, await defaultSanitizeFields({ schema: schema2, getModel, parent }, value));
+        set2(key, await defaultSanitizeFields({
+          schema: schema2,
+          getModel,
+          parent
+        }, value));
       }
       if (key === "populate") {
-        set2(key, await defaultSanitizePopulate({ schema: schema2, getModel, parent }, value));
+        set2(key, await defaultSanitizePopulate({
+          schema: schema2,
+          getModel,
+          parent
+        }, value));
       }
     }, ctx),
     // Remove private fields
     traverseQueryPopulate(visitor$7, ctx)
   )(populate2);
 });
-const sanitizers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+var sanitizers = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   defaultSanitizeFields,
   defaultSanitizeFilters,
@@ -14228,7 +14426,7 @@ const sanitizers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   defaultSanitizePopulate,
   defaultSanitizeSort,
   sanitizePasswords
-}, Symbol.toStringTag, { value: "Module" }));
+});
 const createAPISanitizers = (opts) => {
   const { getModel } = opts;
   const sanitizeInput = (data, schema2, { auth } = {}) => {
@@ -14236,7 +14434,9 @@ const createAPISanitizers = (opts) => {
       throw new Error("Missing schema in sanitizeInput");
     }
     if (fp.isArray(data)) {
-      return Promise.all(data.map((entry) => sanitizeInput(entry, schema2, { auth })));
+      return Promise.all(data.map((entry) => sanitizeInput(entry, schema2, {
+        auth
+      })));
     }
     const nonWritableAttributes = getNonWritableAttributes(schema2);
     const transforms = [
@@ -14244,12 +14444,16 @@ const createAPISanitizers = (opts) => {
       fp.omit(constants$1.ID_ATTRIBUTE),
       fp.omit(constants$1.DOC_ID_ATTRIBUTE),
       // Remove non-writable attributes
-      traverseEntity$1(removeRestrictedFields(nonWritableAttributes), { schema: schema2, getModel })
+      traverseEntity$1(removeRestrictedFields(nonWritableAttributes), {
+        schema: schema2,
+        getModel
+      })
     ];
     if (auth) {
-      transforms.push(
-        traverseEntity$1(removeRestrictedRelations(auth), { schema: schema2, getModel })
-      );
+      transforms.push(traverseEntity$1(removeRestrictedRelations(auth), {
+        schema: schema2,
+        getModel
+      }));
     }
     opts?.sanitizers?.input?.forEach((sanitizer) => transforms.push(sanitizer(schema2)));
     return pipe(...transforms)(data);
@@ -14261,17 +14465,23 @@ const createAPISanitizers = (opts) => {
     if (fp.isArray(data)) {
       const res = new Array(data.length);
       for (let i = 0; i < data.length; i += 1) {
-        res[i] = await sanitizeOutput(data[i], schema2, { auth });
+        res[i] = await sanitizeOutput(data[i], schema2, {
+          auth
+        });
       }
       return res;
     }
     const transforms = [
-      (data2) => defaultSanitizeOutput({ schema: schema2, getModel }, data2)
+      (data2) => defaultSanitizeOutput({
+        schema: schema2,
+        getModel
+      }, data2)
     ];
     if (auth) {
-      transforms.push(
-        traverseEntity$1(removeRestrictedRelations(auth), { schema: schema2, getModel })
-      );
+      transforms.push(traverseEntity$1(removeRestrictedRelations(auth), {
+        schema: schema2,
+        getModel
+      }));
     }
     opts?.sanitizers?.output?.forEach((sanitizer) => transforms.push(sanitizer(schema2)));
     return pipe(...transforms)(data);
@@ -14283,16 +14493,28 @@ const createAPISanitizers = (opts) => {
     const { filters: filters2, sort: sort2, fields: fields2, populate: populate2 } = query;
     const sanitizedQuery = fp.cloneDeep(query);
     if (filters2) {
-      Object.assign(sanitizedQuery, { filters: await sanitizeFilters(filters2, schema2, { auth }) });
+      Object.assign(sanitizedQuery, {
+        filters: await sanitizeFilters(filters2, schema2, {
+          auth
+        })
+      });
     }
     if (sort2) {
-      Object.assign(sanitizedQuery, { sort: await sanitizeSort(sort2, schema2, { auth }) });
+      Object.assign(sanitizedQuery, {
+        sort: await sanitizeSort(sort2, schema2, {
+          auth
+        })
+      });
     }
     if (fields2) {
-      Object.assign(sanitizedQuery, { fields: await sanitizeFields(fields2, schema2) });
+      Object.assign(sanitizedQuery, {
+        fields: await sanitizeFields(fields2, schema2)
+      });
     }
     if (populate2) {
-      Object.assign(sanitizedQuery, { populate: await sanitizePopulate(populate2, schema2) });
+      Object.assign(sanitizedQuery, {
+        populate: await sanitizePopulate(populate2, schema2)
+      });
     }
     return sanitizedQuery;
   };
@@ -14301,13 +14523,21 @@ const createAPISanitizers = (opts) => {
       throw new Error("Missing schema in sanitizeFilters");
     }
     if (fp.isArray(filters2)) {
-      return Promise.all(filters2.map((filter) => sanitizeFilters(filter, schema2, { auth })));
+      return Promise.all(filters2.map((filter) => sanitizeFilters(filter, schema2, {
+        auth
+      })));
     }
-    const transforms = [defaultSanitizeFilters({ schema: schema2, getModel })];
+    const transforms = [
+      defaultSanitizeFilters({
+        schema: schema2,
+        getModel
+      })
+    ];
     if (auth) {
-      transforms.push(
-        traverseQueryFilters(removeRestrictedRelations(auth), { schema: schema2, getModel })
-      );
+      transforms.push(traverseQueryFilters(removeRestrictedRelations(auth), {
+        schema: schema2,
+        getModel
+      }));
     }
     return pipe(...transforms)(filters2);
   };
@@ -14315,11 +14545,17 @@ const createAPISanitizers = (opts) => {
     if (!schema2) {
       throw new Error("Missing schema in sanitizeSort");
     }
-    const transforms = [defaultSanitizeSort({ schema: schema2, getModel })];
+    const transforms = [
+      defaultSanitizeSort({
+        schema: schema2,
+        getModel
+      })
+    ];
     if (auth) {
-      transforms.push(
-        traverseQuerySort(removeRestrictedRelations(auth), { schema: schema2, getModel })
-      );
+      transforms.push(traverseQuerySort(removeRestrictedRelations(auth), {
+        schema: schema2,
+        getModel
+      }));
     }
     return pipe(...transforms)(sort2);
   };
@@ -14327,18 +14563,29 @@ const createAPISanitizers = (opts) => {
     if (!schema2) {
       throw new Error("Missing schema in sanitizeFields");
     }
-    const transforms = [defaultSanitizeFields({ schema: schema2, getModel })];
+    const transforms = [
+      defaultSanitizeFields({
+        schema: schema2,
+        getModel
+      })
+    ];
     return pipe(...transforms)(fields2);
   };
   const sanitizePopulate = (populate2, schema2, { auth } = {}) => {
     if (!schema2) {
       throw new Error("Missing schema in sanitizePopulate");
     }
-    const transforms = [defaultSanitizePopulate({ schema: schema2, getModel })];
+    const transforms = [
+      defaultSanitizePopulate({
+        schema: schema2,
+        getModel
+      })
+    ];
     if (auth) {
-      transforms.push(
-        traverseQueryPopulate(removeRestrictedRelations(auth), { schema: schema2, getModel })
-      );
+      transforms.push(traverseQueryPopulate(removeRestrictedRelations(auth), {
+        schema: schema2,
+        getModel
+      }));
     }
     return pipe(...transforms)(populate2);
   };
@@ -14352,13 +14599,16 @@ const createAPISanitizers = (opts) => {
     populate: sanitizePopulate
   };
 };
-const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+var index$2 = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   createAPISanitizers,
   sanitizers,
   visitors: index$4
-}, Symbol.toStringTag, { value: "Module" }));
-[constants$1.DOC_ID_ATTRIBUTE, constants$1.DOC_ID_ATTRIBUTE];
+});
+[
+  constants$1.DOC_ID_ATTRIBUTE,
+  constants$1.DOC_ID_ATTRIBUTE
+];
 const isCamelCase = (value) => /^[a-z][a-zA-Z0-9]+$/.test(value);
 const isKebabCase = (value) => /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/.test(value);
 const { toString: toString3 } = Object.prototype;
@@ -14389,15 +14639,11 @@ function printSimpleValue(val, quoteStrings = false) {
 function printValue(value, quoteStrings) {
   const result = printSimpleValue(value, quoteStrings);
   if (result !== null) return result;
-  return JSON.stringify(
-    value,
-    function replacer(key, value2) {
-      const result2 = printSimpleValue(this[key], quoteStrings);
-      if (result2 !== null) return result2;
-      return value2;
-    },
-    2
-  );
+  return JSON.stringify(value, function replacer(key, value2) {
+    const result2 = printSimpleValue(this[key], quoteStrings);
+    if (result2 !== null) return result2;
+    return value2;
+  }, 2);
 }
 const isNotNilTest = (value) => !___default__default.default.isNil(value);
 const isNotNullTest = (value) => !___default__default.default.isNull(value);
@@ -14408,71 +14654,35 @@ addMethod(create$3, "notNull", function isNotNull(msg = "${path} cannot be null.
   return this.test("defined", msg, isNotNullTest);
 });
 addMethod(create$3, "isFunction", function isFunction2(message = "${path} is not a function") {
-  return this.test(
-    "is a function",
-    message,
-    (value) => ___default__default.default.isUndefined(value) || ___default__default.default.isFunction(value)
-  );
+  return this.test("is a function", message, (value) => ___default__default.default.isUndefined(value) || ___default__default.default.isFunction(value));
 });
-addMethod(
-  create$2,
-  "isCamelCase",
-  function isCamelCase$1(message = "${path} is not in camel case (anExampleOfCamelCase)") {
-    return this.test(
-      "is in camelCase",
-      message,
-      (value) => value ? isCamelCase(value) : true
-    );
-  }
-);
-addMethod(
-  create$2,
-  "isKebabCase",
-  function isKebabCase$1(message = "${path} is not in kebab case (an-example-of-kebab-case)") {
-    return this.test(
-      "is in kebab-case",
-      message,
-      (value) => value ? isKebabCase(value) : true
-    );
-  }
-);
-addMethod(
-  create$1,
-  "onlyContainsFunctions",
-  function onlyContainsFunctions(message = "${path} contains values that are not functions") {
-    return this.test(
-      "only contains functions",
-      message,
-      (value) => ___default__default.default.isUndefined(value) || value && Object.values(value).every(___default__default.default.isFunction)
-    );
-  }
-);
-addMethod(
-  create,
-  "uniqueProperty",
-  function uniqueProperty(propertyName, message) {
-    return this.test("unique", message, function unique(list) {
-      const errors2 = [];
-      list?.forEach((element, index2) => {
-        const sameElements = list.filter(
-          (e) => fp.get(propertyName, e) === fp.get(propertyName, element)
-        );
-        if (sameElements.length > 1) {
-          errors2.push(
-            this.createError({
-              path: `${this.path}[${index2}].${propertyName}`,
-              message
-            })
-          );
-        }
-      });
-      if (errors2.length) {
-        throw new ValidationError(errors2);
+addMethod(create$2, "isCamelCase", function isCamelCase$1(message = "${path} is not in camel case (anExampleOfCamelCase)") {
+  return this.test("is in camelCase", message, (value) => value ? isCamelCase(value) : true);
+});
+addMethod(create$2, "isKebabCase", function isKebabCase$1(message = "${path} is not in kebab case (an-example-of-kebab-case)") {
+  return this.test("is in kebab-case", message, (value) => value ? isKebabCase(value) : true);
+});
+addMethod(create$1, "onlyContainsFunctions", function onlyContainsFunctions(message = "${path} contains values that are not functions") {
+  return this.test("only contains functions", message, (value) => ___default__default.default.isUndefined(value) || value && Object.values(value).every(___default__default.default.isFunction));
+});
+addMethod(create, "uniqueProperty", function uniqueProperty(propertyName, message) {
+  return this.test("unique", message, function unique(list) {
+    const errors = [];
+    list?.forEach((element, index2) => {
+      const sameElements = list.filter((e) => fp.get(propertyName, e) === fp.get(propertyName, element));
+      if (sameElements.length > 1) {
+        errors.push(this.createError({
+          path: `${this.path}[${index2}].${propertyName}`,
+          message
+        }));
       }
-      return true;
     });
-  }
-);
+    if (errors.length) {
+      throw new ValidationError(errors);
+    }
+    return true;
+  });
+});
 setLocale({
   mixed: {
     notType(options) {
@@ -14545,6 +14755,7 @@ const populateIsWildcardEquivalent = async ({
   schema: schema2,
   populate: populate2
 }) => {
+  if (isEmpty__default.default(populate2)) return false;
   const expandedWildcardQuery = await index$2.sanitizers.defaultSanitizePopulate(
     {
       schema: schema2,
@@ -14578,6 +14789,7 @@ const register = async ({ strapi: strapi2 }) => {
     const cacheService = strapi2.plugin("deep-populate").service("cache");
     const { populate: populate2 } = context.params;
     const returnDeeplyPopulated = replaceWildcard && await populateIsWildcardEquivalent({ strapi: strapi2, schema: context.contentType, populate: populate2 });
+    if (has__default.default(populate2, "__deepPopulated")) unset__default.default(populate2, "__deepPopulated");
     if (useCache && context.action === "delete")
       await cacheService.clear({ ...context.params, contentType: context.uid });
     const originalFields = cloneDeep__default.default(context.fields);
@@ -14586,7 +14798,8 @@ const register = async ({ strapi: strapi2 }) => {
     const result = await next();
     if (!result) return result;
     if (["create", "update"].includes(context.action)) {
-      const { documentId, status: status2, locale: locale2 } = result;
+      const { documentId, publishedAt, locale: locale2 } = result;
+      const status2 = publishedAt !== null ? "published" : "draft";
       if (useCache && context.action === "update")
         await cacheService.clear({ ...context.params, contentType: context.uid });
       if (useCache || returnDeeplyPopulated) {
@@ -14596,13 +14809,15 @@ const register = async ({ strapi: strapi2 }) => {
       }
     }
     if (returnDeeplyPopulated && ["findOne", "findFirst"].includes(context.action)) {
-      const { documentId, status: status2, locale: locale2 } = result;
+      const { documentId, publishedAt, locale: locale2 } = result;
+      const status2 = publishedAt !== null ? "published" : "draft";
       const deepPopulate = await populateService.get({ contentType: context.uid, documentId, status: status2, locale: locale2 });
       return await strapi2.documents(context.uid).findOne({ documentId, status: status2, locale: locale2, fields: originalFields, populate: deepPopulate });
     }
     if (returnDeeplyPopulated && context.action === "findMany") {
       return await Promise.all(
-        result.map(async ({ documentId, status: status2, locale: locale2 }) => {
+        result.map(async ({ documentId, publishedAt, locale: locale2 }) => {
+          const status2 = publishedAt !== null ? "published" : "draft";
           const deepPopulate = await populateService.get({ contentType: context.uid, documentId, status: status2, locale: locale2 });
           return await strapi2.documents(context.uid).findOne({ documentId, status: status2, locale: locale2, fields: originalFields, populate: deepPopulate });
         })
@@ -14614,10 +14829,13 @@ const register = async ({ strapi: strapi2 }) => {
 const getHash = (params) => {
   return `${params.contentType}-${params.documentId}-${params.locale}-${params.status}-${params.omitEmpty ? "sparse" : "full"}-${params.localizations ? "all" : "single"}`;
 };
+const isValid = (entry) => {
+  return entry && !isEmpty__default.default(entry.populate) && has__default.default(entry.populate, "__deepPopulated");
+};
 const cache = ({ strapi: strapi2 }) => ({
   async get(params) {
     const entry = await strapi2.documents("plugin::deep-populate.cache").findFirst({ filters: { hash: { $eq: getHash(params) } } });
-    return entry ? entry.populate : null;
+    return isValid(entry) ? entry.populate : null;
   },
   async set({ populate: populate2, dependencies, ...params }) {
     const documentService = strapi2.documents("plugin::deep-populate.cache");
@@ -14656,6 +14874,11 @@ const cache = ({ strapi: strapi2 }) => ({
 const getRelations = (model) => {
   const filteredAttributes = /* @__PURE__ */ new Set();
   const { populateCreatorFields } = contentTypes.getOptions(model);
+  const { pluginOptions } = model;
+  if (pluginOptions?.i18n?.localized !== true) {
+    filteredAttributes.add("locale");
+    filteredAttributes.add("localizations");
+  }
   if (!populateCreatorFields) {
     filteredAttributes.add(contentTypes.constants.CREATED_BY_ATTRIBUTE);
     filteredAttributes.add(contentTypes.constants.UPDATED_BY_ATTRIBUTE);
@@ -14911,6 +15134,7 @@ async function populate$1(params) {
     __deny: deny,
     __allow: allow
   });
+  populated.__deepPopulated = true;
   return { populate: populated, dependencies: [...resolvedRelations.keys()] };
 }
 const populate = ({ strapi: strapi2 }) => ({