@strapi/utils 5.0.0-beta.1 → 5.0.0-beta.10

package/dist/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const _$1 = require("lodash");
+const _ = require("lodash");
+const dates$1 = require("date-fns");
 const fp = require("lodash/fp");
 const crypto = require("crypto");
 const nodeMachineId = require("node-machine-id");
@@ -11,6 +12,7 @@ const execa = require("execa");
 const preferredPM = require("preferred-pm");
 const node_stream = require("node:stream");
 const slugify = require("@sindresorhus/slugify");
+const zod = require("zod");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 function _interopNamespace(e) {
   if (e && e.__esModule)
@@ -49,21 +51,20 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const ___default = /* @__PURE__ */ _interopDefault(_$1);
+const ___namespace = /* @__PURE__ */ _interopNamespace(_);
+const dates__namespace = /* @__PURE__ */ _interopNamespace(dates$1);
 const yup__namespace = /* @__PURE__ */ _interopNamespace(yup$1);
 const pMap__default = /* @__PURE__ */ _interopDefault(pMap);
 const execa__default = /* @__PURE__ */ _interopDefault(execa);
 const preferredPM__default = /* @__PURE__ */ _interopDefault(preferredPM);
 const slugify__default = /* @__PURE__ */ _interopDefault(slugify);
-const _ = require("lodash");
-const dates$1 = require("date-fns");
 const timeRegex = /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$/;
 const isDate = (v) => {
-  return dates$1.isDate(v);
+  return dates__namespace.isDate(v);
 };
 const parseTime = (value) => {
   if (isDate(value)) {
-    return dates$1.format(value, "HH:mm:ss.SSS");
+    return dates__namespace.format(value, "HH:mm:ss.SSS");
   }
   if (typeof value !== "string") {
     throw new Error(`Expected a string, got a ${typeof value}`);
@@ -73,20 +74,20 @@ const parseTime = (value) => {
     throw new Error("Invalid time format, expected HH:mm:ss.SSS");
   }
   const [, hours, minutes, seconds, fraction = ".000"] = result;
-  const fractionPart = _.padEnd(fraction.slice(1), 3, "0");
+  const fractionPart = ___namespace.padEnd(fraction.slice(1), 3, "0");
   return `${hours}:${minutes}:${seconds}.${fractionPart}`;
 };
 const parseDate = (value) => {
   if (isDate(value)) {
-    return dates$1.format(value, "yyyy-MM-dd");
+    return dates__namespace.format(value, "yyyy-MM-dd");
   }
   if (typeof value !== "string") {
     throw new Error(`Expected a string, got a ${typeof value}`);
   }
   try {
-    const date = dates$1.parseISO(value);
-    if (dates$1.isValid(date))
-      return dates$1.format(date, "yyyy-MM-dd");
+    const date = dates__namespace.parseISO(value);
+    if (dates__namespace.isValid(date))
+      return dates__namespace.format(date, "yyyy-MM-dd");
     throw new Error(`Invalid format, expected an ISO compatible date`);
   } catch (error) {
     throw new Error(`Invalid format, expected an ISO compatible date`);
@@ -100,11 +101,11 @@ const parseDateTimeOrTimestamp = (value) => {
     throw new Error(`Expected a string, got a ${typeof value}`);
   }
   try {
-    const date = dates$1.parseISO(value);
-    if (dates$1.isValid(date))
+    const date = dates__namespace.parseISO(value);
+    if (dates__namespace.isValid(date))
       return date;
-    const milliUnixDate = dates$1.parse(value, "T", /* @__PURE__ */ new Date());
-    if (dates$1.isValid(milliUnixDate))
+    const milliUnixDate = dates__namespace.parse(value, "T", /* @__PURE__ */ new Date());
+    if (dates__namespace.isValid(milliUnixDate))
       return milliUnixDate;
     throw new Error(`Invalid format, expected a timestamp or an ISO date`);
   } catch (error) {
@@ -138,7 +139,7 @@ const parseType = (options) => {
     case "biginteger":
     case "float":
     case "decimal": {
-      return _.toNumber(value);
+      return ___namespace.toNumber(value);
     }
     case "time": {
       return parseTime(value);
@@ -155,32 +156,32 @@ const parseType = (options) => {
   }
 };
 function envFn(key, defaultValue) {
-  return ___default.default.has(process.env, key) ? process.env[key] : defaultValue;
+  return ___namespace.default.has(process.env, key) ? process.env[key] : defaultValue;
 }
 function getKey(key) {
   return process.env[key] ?? "";
 }
 const utils = {
   int(key, defaultValue) {
-    if (!___default.default.has(process.env, key)) {
+    if (!___namespace.default.has(process.env, key)) {
       return defaultValue;
     }
     return parseInt(getKey(key), 10);
   },
   float(key, defaultValue) {
-    if (!___default.default.has(process.env, key)) {
+    if (!___namespace.default.has(process.env, key)) {
       return defaultValue;
     }
     return parseFloat(getKey(key));
   },
   bool(key, defaultValue) {
-    if (!___default.default.has(process.env, key)) {
+    if (!___namespace.default.has(process.env, key)) {
       return defaultValue;
     }
     return getKey(key) === "true";
   },
   json(key, defaultValue) {
-    if (!___default.default.has(process.env, key)) {
+    if (!___namespace.default.has(process.env, key)) {
       return defaultValue;
     }
     try {
@@ -193,7 +194,7 @@ const utils = {
     }
   },
   array(key, defaultValue) {
-    if (!___default.default.has(process.env, key)) {
+    if (!___namespace.default.has(process.env, key)) {
       return defaultValue;
     }
     let value = getKey(key);
@@ -201,11 +202,11 @@ const utils = {
       value = value.substring(1, value.length - 1);
     }
     return value.split(",").map((v) => {
-      return ___default.default.trim(___default.default.trim(v, " "), '"');
+      return ___namespace.default.trim(___namespace.default.trim(v, " "), '"');
     });
   },
   date(key, defaultValue) {
-    if (!___default.default.has(process.env, key)) {
+    if (!___namespace.default.has(process.env, key)) {
       return defaultValue;
     }
     return new Date(getKey(key));
@@ -272,12 +273,12 @@ const getCreatorFields = (model) => {
 const getNonWritableAttributes = (model) => {
   if (!model)
     return [];
-  const nonWritableAttributes = ___default.default.reduce(
+  const nonWritableAttributes = ___namespace.default.reduce(
     model.attributes,
     (acc, attr, attrName) => attr.writable === false ? acc.concat(attrName) : acc,
     []
   );
-  return ___default.default.uniq([
+  return ___namespace.default.uniq([
     ID_ATTRIBUTE$4,
     DOC_ID_ATTRIBUTE$4,
     ...getTimestamps(model),
@@ -287,28 +288,37 @@ const getNonWritableAttributes = (model) => {
 const getWritableAttributes = (model) => {
   if (!model)
     return [];
-  return ___default.default.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
+  return ___namespace.default.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
 };
 const isWritableAttribute = (model, attributeName) => {
   return getWritableAttributes(model).includes(attributeName);
 };
 const getNonVisibleAttributes = (model) => {
-  const nonVisibleAttributes = ___default.default.reduce(
+  const nonVisibleAttributes = ___namespace.default.reduce(
     model.attributes,
     (acc, attr, attrName) => attr.visible === false ? acc.concat(attrName) : acc,
     []
   );
-  return ___default.default.uniq([ID_ATTRIBUTE$4, DOC_ID_ATTRIBUTE$4, ...getTimestamps(model), ...nonVisibleAttributes]);
+  return ___namespace.default.uniq([ID_ATTRIBUTE$4, DOC_ID_ATTRIBUTE$4, ...getTimestamps(model), ...nonVisibleAttributes]);
 };
 const getVisibleAttributes = (model) => {
-  return ___default.default.difference(___default.default.keys(model.attributes), getNonVisibleAttributes(model));
+  return ___namespace.default.difference(___namespace.default.keys(model.attributes), getNonVisibleAttributes(model));
 };
 const isVisibleAttribute = (model, attributeName) => {
   return getVisibleAttributes(model).includes(attributeName);
 };
-const getOptions = (model) => ___default.default.assign({ draftAndPublish: false }, ___default.default.get(model, "options", {}));
-const hasDraftAndPublish = (model) => ___default.default.get(model, "options.draftAndPublish", false) === true;
-const isDraft = (data, model) => hasDraftAndPublish(model) && ___default.default.get(data, PUBLISHED_AT_ATTRIBUTE$1) === null;
+const getOptions = (model) => ___namespace.default.assign({ draftAndPublish: false }, ___namespace.default.get(model, "options", {}));
+const hasDraftAndPublish = (model) => ___namespace.default.get(model, "options.draftAndPublish", false) === true;
+const isDraft = (data, model) => hasDraftAndPublish(model) && ___namespace.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);
+};
+const isComponentSchema = (data) => {
+  return isSchema(data) && data.modelType === "component";
+};
+const isContentTypeSchema = (data) => {
+  return isSchema(data) && data.modelType === "contentType";
+};
 const isSingleType = ({ kind = COLLECTION_TYPE }) => kind === SINGLE_TYPE;
 const isCollectionType = ({ kind = COLLECTION_TYPE }) => kind === COLLECTION_TYPE;
 const isKind = (kind) => (model) => model.kind === kind;
@@ -317,9 +327,9 @@ const getStoredPrivateAttributes = (model) => fp.union(
   fp.getOr([], "options.privateAttributes", model)
 );
 const getPrivateAttributes = (model) => {
-  return ___default.default.union(
+  return ___namespace.default.union(
     getStoredPrivateAttributes(model),
-    ___default.default.keys(___default.default.pickBy(model.attributes, (attr) => !!attr.private))
+    ___namespace.default.keys(___namespace.default.pickBy(model.attributes, (attr) => !!attr.private))
   );
 };
 const isPrivateAttribute = (model, attributeName) => {
@@ -329,17 +339,22 @@ const isPrivateAttribute = (model, attributeName) => {
   return getStoredPrivateAttributes(model).includes(attributeName);
 };
 const isScalarAttribute = (attribute) => {
-  return !["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 hasRelationReordering = (attribute) => isRelationalAttribute(attribute) && HAS_RELATION_REORDERING.includes(attribute.relation);
 const isComponentAttribute = (attribute) => ["component", "dynamiczone"].includes(attribute?.type);
-const isDynamicZoneAttribute = (attribute) => attribute?.type === "dynamiczone";
+const isDynamicZoneAttribute = (attribute) => !!attribute && attribute.type === "dynamiczone";
 const isMorphToRelationalAttribute = (attribute) => {
-  return isRelationalAttribute(attribute) && attribute?.relation?.startsWith?.("morphTo");
+  return !!attribute && isRelationalAttribute(attribute) && attribute.relation?.startsWith?.("morphTo");
 };
 const getComponentAttributes = (schema) => {
-  return ___default.default.reduce(
+  return ___namespace.default.reduce(
     schema.attributes,
     (acc, attr, attrName) => {
       if (isComponentAttribute(attr))
@@ -350,7 +365,7 @@ const getComponentAttributes = (schema) => {
   );
 };
 const getScalarAttributes = (schema) => {
-  return ___default.default.reduce(
+  return ___namespace.default.reduce(
     schema.attributes,
     (acc, attr, attrName) => {
       if (isScalarAttribute(attr))
@@ -360,11 +375,22 @@ const getScalarAttributes = (schema) => {
     []
   );
 };
+const getRelationalAttributes = (schema) => {
+  return ___namespace.default.reduce(
+    schema.attributes,
+    (acc, attr, attrName) => {
+      if (isRelationalAttribute(attr))
+        acc.push(attrName);
+      return acc;
+    },
+    []
+  );
+};
 const isTypedAttribute = (attribute, type) => {
-  return ___default.default.has(attribute, "type") && attribute.type === type;
+  return ___namespace.default.has(attribute, "type") && attribute.type === type;
 };
 const getContentTypeRoutePrefix = (contentType) => {
-  return isSingleType(contentType) ? ___default.default.kebabCase(contentType.info.singularName) : ___default.default.kebabCase(contentType.info.pluralName);
+  return isSingleType(contentType) ? ___namespace.default.kebabCase(contentType.info.singularName) : ___namespace.default.kebabCase(contentType.info.pluralName);
 };
 const contentTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
@@ -372,17 +398,22 @@ const contentTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.define
   getComponentAttributes,
   getContentTypeRoutePrefix,
   getCreatorFields,
+  getDoesAttributeRequireValidation,
   getNonVisibleAttributes,
   getNonWritableAttributes,
   getOptions,
   getPrivateAttributes,
+  getRelationalAttributes,
   getScalarAttributes,
   getTimestamps,
   getVisibleAttributes,
   getWritableAttributes,
   hasDraftAndPublish,
+  hasRelationReordering,
   isCollectionType,
   isComponentAttribute,
+  isComponentSchema,
+  isContentTypeSchema,
   isDraft,
   isDynamicZoneAttribute,
   isKind,
@@ -391,6 +422,7 @@ const contentTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.define
   isPrivateAttribute,
   isRelationalAttribute,
   isScalarAttribute,
+  isSchema,
   isSingleType,
   isTypedAttribute,
   isVisibleAttribute,
@@ -545,28 +577,29 @@ const providerFactory = (options = {}) => {
 };
 const traverseEntity = async (visitor2, options, entity) => {
   const { path = { raw: null, attribute: null }, schema, getModel } = options;
+  let parent = options.parent;
   const traverseMorphRelationTarget = async (visitor22, path2, entry) => {
     const targetSchema = getModel(entry.__type);
-    const traverseOptions = { schema: targetSchema, path: path2, getModel };
+    const traverseOptions = { schema: targetSchema, path: path2, getModel, parent };
     return traverseEntity(visitor22, traverseOptions, entry);
   };
   const traverseRelationTarget = (schema2) => async (visitor22, path2, entry) => {
-    const traverseOptions = { schema: schema2, path: path2, getModel };
+    const traverseOptions = { schema: schema2, path: path2, getModel, parent };
     return traverseEntity(visitor22, traverseOptions, entry);
   };
   const traverseMediaTarget = async (visitor22, path2, entry) => {
     const targetSchemaUID = "plugin::upload.file";
     const targetSchema = getModel(targetSchemaUID);
-    const traverseOptions = { schema: targetSchema, path: path2, getModel };
+    const traverseOptions = { schema: targetSchema, path: path2, getModel, parent };
     return traverseEntity(visitor22, traverseOptions, entry);
   };
   const traverseComponent = async (visitor22, path2, schema2, entry) => {
-    const traverseOptions = { schema: schema2, path: path2, getModel };
+    const traverseOptions = { schema: schema2, path: path2, getModel, parent };
     return traverseEntity(visitor22, traverseOptions, entry);
   };
   const visitDynamicZoneEntry = async (visitor22, path2, entry) => {
     const targetSchema = getModel(entry.__component);
-    const traverseOptions = { schema: targetSchema, path: path2, getModel };
+    const traverseOptions = { schema: targetSchema, path: path2, getModel, parent };
     return traverseEntity(visitor22, traverseOptions, entry);
   };
   if (!fp.isObject(entity) || fp.isNil(schema)) {
@@ -578,9 +611,6 @@ const traverseEntity = async (visitor2, options, entity) => {
   for (let i = 0; i < keys.length; i += 1) {
     const key = keys[i];
     const attribute = schema.attributes[key];
-    if (fp.isNil(attribute)) {
-      continue;
-    }
     const newPath = { ...path };
     newPath.raw = fp.isNil(path.raw) ? key : `${path.raw}.${key}`;
     if (!fp.isNil(attribute)) {
@@ -593,13 +623,15 @@ const traverseEntity = async (visitor2, options, entity) => {
       value: copy[key],
       attribute,
       path: newPath,
-      getModel
+      getModel,
+      parent
     };
     await visitor2(visitorOptions, visitorUtils);
     const value = copy[key];
-    if (fp.isNil(value)) {
+    if (fp.isNil(value) || fp.isNil(attribute)) {
       continue;
     }
+    parent = { schema, key, attribute, path: newPath };
     if (isRelationalAttribute(attribute)) {
       const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
       const method = isMorphRelation ? traverseMorphRelationTarget : traverseRelationTarget(getModel(attribute.target));
@@ -897,7 +929,7 @@ const convertCountQueryParams = (countQuery) => {
 const convertOrderingQueryParams = (ordering) => {
   return ordering;
 };
-const isPlainObject = (value) => ___default.default.isPlainObject(value);
+const isPlainObject = (value) => ___namespace.default.isPlainObject(value);
 const isStringArray$3 = (value) => fp.isArray(value) && value.every(fp.isString);
 const createTransformer = ({ getModel }) => {
   const convertSortQueryParams = (sortQuery) => {
@@ -930,7 +962,7 @@ const createTransformer = ({ getModel }) => {
       throw new Error("Field cannot be empty");
     }
     validateOrder(order);
-    return ___default.default.set({}, field, order);
+    return ___namespace.default.set({}, field, order);
   };
   const convertNestedSortQueryParam = (sortQuery) => {
     const transformedSort = {};
@@ -948,15 +980,15 @@ const createTransformer = ({ getModel }) => {
     return transformedSort;
   };
   const convertStartQueryParams = (startQuery) => {
-    const startAsANumber = ___default.default.toNumber(startQuery);
-    if (!___default.default.isInteger(startAsANumber) || startAsANumber < 0) {
+    const startAsANumber = ___namespace.default.toNumber(startQuery);
+    if (!___namespace.default.isInteger(startAsANumber) || startAsANumber < 0) {
       throw new Error(`convertStartQueryParams expected a positive integer got ${startAsANumber}`);
     }
     return startAsANumber;
   };
   const convertLimitQueryParams = (limitQuery) => {
-    const limitAsANumber = ___default.default.toNumber(limitQuery);
-    if (!___default.default.isInteger(limitAsANumber) || limitAsANumber !== -1 && limitAsANumber < 0) {
+    const limitAsANumber = ___namespace.default.toNumber(limitQuery);
+    if (!___namespace.default.isInteger(limitAsANumber) || limitAsANumber !== -1 && limitAsANumber < 0) {
       throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
     }
     if (limitAsANumber === -1) {
@@ -1002,44 +1034,62 @@ const createTransformer = ({ getModel }) => {
       return true;
     }
     if (typeof populate2 === "string") {
-      return populate2.split(",").map((value) => ___default.default.trim(value));
+      return populate2.split(",").map((value) => ___namespace.default.trim(value));
     }
     if (Array.isArray(populate2)) {
-      return ___default.default.uniq(
+      return ___namespace.default.uniq(
         populate2.flatMap((value) => {
           if (typeof value !== "string") {
             throw new InvalidPopulateError();
           }
-          return value.split(",").map((value2) => ___default.default.trim(value2));
+          return value.split(",").map((value2) => ___namespace.default.trim(value2));
         })
       );
     }
-    if (___default.default.isPlainObject(populate2)) {
+    if (___namespace.default.isPlainObject(populate2)) {
       return convertPopulateObject(populate2, schema);
     }
     throw new InvalidPopulateError();
   };
-  const hasFragmentPopulateDefined = (populate2) => {
+  const hasPopulateFragmentDefined = (populate2) => {
     return typeof populate2 === "object" && "on" in populate2 && !fp.isNil(populate2.on);
   };
+  const hasCountDefined = (populate2) => {
+    return typeof populate2 === "object" && "count" in populate2 && typeof populate2.count === "boolean";
+  };
   const convertPopulateObject = (populate2, schema) => {
     if (!schema) {
       return {};
     }
     const { attributes } = schema;
     return Object.entries(populate2).reduce((acc, [key, subPopulate]) => {
-      if (___default.default.isBoolean(subPopulate)) {
-        return { ...acc, [key]: subPopulate };
+      if (___namespace.default.isString(subPopulate)) {
+        try {
+          const subPopulateAsBoolean = parseType({ type: "boolean", value: subPopulate });
+          return subPopulateAsBoolean === true ? { ...acc, [key]: true } : acc;
+        } catch {
+        }
+      }
+      if (___namespace.default.isBoolean(subPopulate)) {
+        return subPopulate === true ? { ...acc, [key]: true } : acc;
       }
       const attribute = attributes[key];
       if (!attribute) {
         return acc;
       }
-      const isAllowedAttributeForFragmentPopulate = isDynamicZoneAttribute(attribute) || isMorphToRelationalAttribute(attribute);
-      if (isAllowedAttributeForFragmentPopulate && hasFragmentPopulateDefined(subPopulate)) {
-        return {
-          ...acc,
-          [key]: {
+      const isMorphLikeRelationalAttribute = isDynamicZoneAttribute(attribute) || isMorphToRelationalAttribute(attribute);
+      if (isMorphLikeRelationalAttribute) {
+        const hasInvalidProperties = Object.keys(subPopulate).some(
+          (key2) => !["on", "count"].includes(key2)
+        );
+        if (hasInvalidProperties) {
+          throw new Error(
+            `Invalid nested populate for ${schema.info?.singularName}.${key} (${schema.uid}). Expected a fragment ("on") or "count" but found ${JSON.stringify(subPopulate)}`
+          );
+        }
+        const newSubPopulate = {};
+        if (hasPopulateFragmentDefined(subPopulate)) {
+          Object.assign(newSubPopulate, {
             on: Object.entries(subPopulate.on).reduce(
               (acc2, [type, typeSubPopulate]) => ({
                 ...acc2,
@@ -1047,21 +1097,15 @@ const createTransformer = ({ getModel }) => {
               }),
               {}
             )
-          }
-        };
-      }
-      if (isDynamicZoneAttribute(attribute)) {
-        const populates = attribute.components.map((uid) => getModel(uid)).map((schema2) => convertNestedPopulate(subPopulate, schema2)).map((populate22) => populate22 === true ? {} : populate22).filter((populate22) => populate22 !== false);
-        if (fp.isEmpty(populates)) {
-          return acc;
+          });
         }
-        return {
-          ...acc,
-          [key]: fp.mergeAll(populates)
-        };
+        if (hasCountDefined(subPopulate)) {
+          Object.assign(newSubPopulate, { count: subPopulate.count });
+        }
+        return { ...acc, [key]: newSubPopulate };
       }
-      if (isMorphToRelationalAttribute(attribute)) {
-        return { ...acc, [key]: convertNestedPopulate(subPopulate, void 0) };
+      if (!isMorphLikeRelationalAttribute && hasPopulateFragmentDefined(subPopulate)) {
+        throw new Error(`Using fragments is not permitted to populate "${key}" in "${schema.uid}"`);
       }
       let targetSchemaUID;
       if (attribute.type === "relation") {
@@ -1088,10 +1132,10 @@ const createTransformer = ({ getModel }) => {
     }, {});
   };
   const convertNestedPopulate = (subPopulate, schema) => {
-    if (___default.default.isString(subPopulate)) {
+    if (___namespace.default.isString(subPopulate)) {
       return parseType({ type: "boolean", value: subPopulate, forceCast: true });
     }
-    if (___default.default.isBoolean(subPopulate)) {
+    if (___namespace.default.isBoolean(subPopulate)) {
       return subPopulate;
     }
     if (!isPlainObject(subPopulate)) {
@@ -1137,12 +1181,12 @@ const createTransformer = ({ getModel }) => {
       return void 0;
     }
     if (typeof fields2 === "string") {
-      const fieldsValues = fields2.split(",").map((value) => ___default.default.trim(value));
-      return ___default.default.uniq([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3, ...fieldsValues]);
+      const fieldsValues = fields2.split(",").map((value) => ___namespace.default.trim(value));
+      return ___namespace.default.uniq([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3, ...fieldsValues]);
     }
     if (isStringArray$3(fields2)) {
       const fieldsValues = fields2.flatMap((value) => convertFieldsQueryParams(value, depth + 1)).filter((v) => !fp.isNil(v));
-      return ___default.default.uniq([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3, ...fieldsValues]);
+      return ___namespace.default.uniq([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3, ...fieldsValues]);
     }
     throw new Error("Invalid fields parameter. Expected a string or an array of strings");
   };
@@ -1817,7 +1861,8 @@ const populate = traverseFactory().intercept(isStringArray$1, async (visitor2, o
         return;
       }
       const newValue2 = await recurse(visitor2, { schema, path, getModel }, { on: value?.on });
-      set(key, { on: newValue2 });
+      set(key, newValue2);
+      return;
     }
     const targetSchemaUID = attribute.target;
     const targetSchema = getModel(targetSchemaUID);
@@ -1839,36 +1884,15 @@ const populate = traverseFactory().intercept(isStringArray$1, async (visitor2, o
   const targetSchema = getModel(attribute.component);
   const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
   set(key, newValue);
-}).onDynamicZone(
-  async ({ key, value, attribute, schema, visitor: visitor2, path, getModel }, { set, recurse }) => {
-    if (fp.isNil(value)) {
-      return;
-    }
-    if (fp.isObject(value)) {
-      const { components } = attribute;
-      const newValue = {};
-      let newProperties = fp.omit("on", value);
-      for (const componentUID of components) {
-        const componentSchema = getModel(componentUID);
-        const properties = await recurse(
-          visitor2,
-          { schema: componentSchema, path, getModel },
-          value
-        );
-        newProperties = fp.merge(newProperties, properties);
-      }
-      Object.assign(newValue, newProperties);
-      if ("on" in value && value.on) {
-        const newOn = await recurse(visitor2, { schema, path, getModel }, { on: value.on });
-        Object.assign(newValue, newOn);
-      }
-      set(key, newValue);
-    } else {
-      const newValue = await recurse(visitor2, { schema, path, getModel }, value);
-      set(key, newValue);
-    }
+}).onDynamicZone(async ({ key, value, schema, visitor: visitor2, path, getModel }, { set, recurse }) => {
+  if (fp.isNil(value) || !fp.isObject(value)) {
+    return;
   }
-);
+  if ("on" in value && value.on) {
+    const newOn = await recurse(visitor2, { schema, path, getModel }, { on: value.on });
+    set(key, newOn);
+  }
+});
 const traverseQueryPopulate = fp.curry(populate.traverse);
 const isStringArray = (value) => fp.isArray(value) && value.every(fp.isString);
 const fields = traverseFactory().intercept(isStringArray, async (visitor2, options, fields2, { recurse }) => {
@@ -2167,13 +2191,16 @@ const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   sanitizers,
   visitors: index$4
 }, Symbol.toStringTag, { value: "Module" }));
-const throwInvalidParam = ({ key, path }) => {
-  const msg = path && path !== key ? `Invalid parameter ${key} at ${path}` : `Invalid parameter ${key}`;
-  throw new ValidationError(msg);
+const throwInvalidKey = ({ key, path }) => {
+  const msg = path && path !== key ? `Invalid key ${key} at ${path}` : `Invalid key ${key}`;
+  throw new ValidationError(msg, {
+    key,
+    path
+  });
 };
 const visitor$3 = ({ key, attribute, path }) => {
   if (attribute?.type === "password") {
-    throwInvalidParam({ key, path: path.attribute });
+    throwInvalidKey({ key, path: path.attribute });
   }
 };
 const visitor$2 = ({ schema, key, attribute, path }) => {
@@ -2182,7 +2209,7 @@ const visitor$2 = ({ schema, key, attribute, path }) => {
   }
   const isPrivate = attribute.private === true || isPrivateAttribute(schema, key);
   if (isPrivate) {
-    throwInvalidParam({ key, path: path.attribute });
+    throwInvalidKey({ key, path: path.attribute });
   }
 };
 const ACTIONS_TO_VERIFY = ["find"];
@@ -2200,7 +2227,7 @@ const throwRestrictedRelations = (auth) => async ({ data, key, attribute, schema
       const scopes = ACTIONS_TO_VERIFY.map((action) => `${element.__type}.${action}`);
       const isAllowed = await hasAccessToSomeScopes(scopes, auth);
       if (!isAllowed) {
-        throwInvalidParam({ key, path: path.attribute });
+        throwInvalidKey({ key, path: path.attribute });
       }
     }
   };
@@ -2208,7 +2235,7 @@ const throwRestrictedRelations = (auth) => async ({ data, key, attribute, schema
     const scopes = ACTIONS_TO_VERIFY.map((action) => `${attribute.target}.${action}`);
     const isAllowed = await hasAccessToSomeScopes(scopes, auth);
     if (!isAllowed) {
-      throwInvalidParam({ key, path: path.attribute });
+      throwInvalidKey({ key, path: path.attribute });
     }
   };
   const isCreatorRelation = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(key);
@@ -2234,12 +2261,12 @@ const hasAccessToSomeScopes = async (scopes, auth) => {
 };
 const visitor$1 = ({ key, attribute, path }) => {
   if (isMorphToRelationalAttribute(attribute)) {
-    throwInvalidParam({ key, path: path.attribute });
+    throwInvalidKey({ key, path: path.attribute });
   }
 };
 const visitor = ({ key, attribute, path }) => {
   if (isDynamicZoneAttribute(attribute)) {
-    throwInvalidParam({ key, path: path.attribute });
+    throwInvalidKey({ key, path: path.attribute });
   }
 };
 const throwDisallowedFields = (allowedFields = null) => ({ key, path: { attribute: path } }) => {
@@ -2261,7 +2288,7 @@ const throwDisallowedFields = (allowedFields = null) => ({ key, path: { attribut
   if (isPathAllowed) {
     return;
   }
-  throwInvalidParam({ key, path });
+  throwInvalidKey({ key, path });
 };
 const getContainedPaths = (path) => {
   const parts = fp.toPath(path);
@@ -2271,7 +2298,7 @@ const getContainedPaths = (path) => {
 };
 const throwRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path } }) => {
   if (restrictedFields === null) {
-    throwInvalidParam({ key, path });
+    throwInvalidKey({ key, path });
   }
   if (!(fp.isArray(restrictedFields) && restrictedFields.every(fp.isString))) {
     throw new TypeError(
@@ -2279,14 +2306,44 @@ const throwRestrictedFields = (restrictedFields = null) => ({ key, path: { attri
     );
   }
   if (restrictedFields.includes(path)) {
-    throwInvalidParam({ key, path });
+    throwInvalidKey({ key, path });
   }
   const isRestrictedNested = restrictedFields.some(
     (allowedPath) => path?.toString().startsWith(`${allowedPath}.`)
   );
   if (isRestrictedNested) {
-    throwInvalidParam({ key, path });
+    throwInvalidKey({ key, path });
+  }
+};
+const ID_FIELDS = [constants$1.DOC_ID_ATTRIBUTE, constants$1.DOC_ID_ATTRIBUTE];
+const ALLOWED_ROOT_LEVEL_FIELDS = [...ID_FIELDS];
+const MORPH_TO_ALLOWED_FIELDS = ["__type"];
+const DYNAMIC_ZONE_ALLOWED_FIELDS = ["__component"];
+const RELATION_REORDERING_FIELDS = ["connect", "disconnect", "set", "options"];
+const throwUnrecognizedFields = ({ key, attribute, path, schema, parent }) => {
+  if (attribute) {
+    return;
+  }
+  if (path.attribute === null) {
+    if (ALLOWED_ROOT_LEVEL_FIELDS.includes(key)) {
+      return;
+    }
+    return throwInvalidKey({ key, path: attribute });
+  }
+  if (isMorphToRelationalAttribute(parent?.attribute) && MORPH_TO_ALLOWED_FIELDS.includes(key)) {
+    return;
+  }
+  if (isComponentSchema(schema) && isDynamicZoneAttribute(parent?.attribute) && DYNAMIC_ZONE_ALLOWED_FIELDS.includes(key)) {
+    return;
+  }
+  if (hasRelationReordering(parent?.attribute) && RELATION_REORDERING_FIELDS.includes(key)) {
+    return;
+  }
+  const canUseID = isRelationalAttribute(parent?.attribute) || isMediaAttribute(parent?.attribute);
+  if (canUseID && !ID_FIELDS.includes(key)) {
+    return;
   }
+  throwInvalidKey({ key, path: attribute });
 };
 const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
@@ -2296,7 +2353,8 @@ const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   throwPassword: visitor$3,
   throwPrivate: visitor$2,
   throwRestrictedFields,
-  throwRestrictedRelations
+  throwRestrictedRelations,
+  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) => {
@@ -2317,7 +2375,7 @@ const defaultValidateFilters = fp.curry((ctx, filters2) => {
       }
       const isAttribute = !!attribute;
       if (!isAttribute && !isOperator(key)) {
-        throwInvalidParam({ key, path: path.attribute });
+        throwInvalidKey({ key, path: path.attribute });
       }
     }, ctx),
     // dynamic zones from filters
@@ -2342,7 +2400,7 @@ const defaultValidateSort = fp.curry((ctx, sort2) => {
         return;
       }
       if (!attribute) {
-        throwInvalidParam({ key, path: path.attribute });
+        throwInvalidKey({ key, path: path.attribute });
       }
     }, ctx),
     // dynamic zones from sort
@@ -2359,7 +2417,7 @@ const defaultValidateSort = fp.curry((ctx, sort2) => {
         return;
       }
       if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
-        throwInvalidParam({ key, path: path.attribute });
+        throwInvalidKey({ key, path: path.attribute });
       }
     }, ctx)
   )(sort2);
@@ -2375,7 +2433,7 @@ const defaultValidateFields = fp.curry((ctx, fields2) => {
         return;
       }
       if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
-        throwInvalidParam({ key, path: path.attribute });
+        throwInvalidKey({ key, path: path.attribute });
       }
     }, ctx),
     // private fields
@@ -2470,15 +2528,18 @@ const createAPIValidators = (opts) => {
       (data2) => {
         if (fp.isObject(data2)) {
           if (ID_ATTRIBUTE in data2) {
-            throwInvalidParam({ key: ID_ATTRIBUTE });
+            throwInvalidKey({ key: ID_ATTRIBUTE });
           }
           if (DOC_ID_ATTRIBUTE in data2) {
-            throwInvalidParam({ key: DOC_ID_ATTRIBUTE });
+            throwInvalidKey({ key: DOC_ID_ATTRIBUTE });
           }
         }
+        return data2;
       },
       // non-writable attributes
-      traverseEntity$1(throwRestrictedFields(nonWritableAttributes), { schema, getModel })
+      traverseEntity$1(throwRestrictedFields(nonWritableAttributes), { schema, getModel }),
+      // unrecognized attributes
+      traverseEntity$1(throwUnrecognizedFields, { schema, getModel })
     ];
     if (auth) {
       transforms.push(
@@ -2489,7 +2550,14 @@ const createAPIValidators = (opts) => {
       );
     }
     opts?.validators?.input?.forEach((validator) => transforms.push(validator(schema)));
-    await pipe(...transforms)(data);
+    try {
+      await pipe(...transforms)(data);
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        e.details.source = "body";
+      }
+      throw e;
+    }
   };
   const validateQuery = async (query, schema, { auth } = {}) => {
     if (!schema) {
@@ -2526,7 +2594,15 @@ const createAPIValidators = (opts) => {
         })
       );
     }
-    await pipe(...transforms)(filters2);
+    try {
+      await pipe(...transforms)(filters2);
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        e.details.source = "query";
+        e.details.param = "filters";
+      }
+      throw e;
+    }
   };
   const validateSort = async (sort2, schema, { auth } = {}) => {
     if (!schema) {
@@ -2541,14 +2617,30 @@ const createAPIValidators = (opts) => {
         })
       );
     }
-    await pipe(...transforms)(sort2);
+    try {
+      await pipe(...transforms)(sort2);
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        e.details.source = "query";
+        e.details.param = "sort";
+      }
+      throw e;
+    }
   };
   const validateFields = async (fields2, schema) => {
     if (!schema) {
       throw new Error("Missing schema in validateFields");
     }
     const transforms = [defaultValidateFields({ schema, getModel })];
-    await pipe(...transforms)(fields2);
+    try {
+      await pipe(...transforms)(fields2);
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        e.details.source = "query";
+        e.details.param = "fields";
+      }
+      throw e;
+    }
   };
   const validatePopulate = async (populate2, schema, { auth } = {}) => {
     if (!schema) {
@@ -2563,7 +2655,15 @@ const createAPIValidators = (opts) => {
         })
       );
     }
-    await pipe(...transforms)(populate2);
+    try {
+      await pipe(...transforms)(populate2);
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        e.details.source = "query";
+        e.details.param = "populate";
+      }
+      throw e;
+    }
   };
   return {
     input: validateInput,
@@ -2647,8 +2747,57 @@ const withDefaultPagination = (args, { defaults = {}, maxLimit = -1 } = {}) => {
   );
   return replacePaginationAttributes(args);
 };
+const transformPagedPaginationInfo = (paginationInfo, total) => {
+  if (!fp.isNil(paginationInfo.page)) {
+    const page = paginationInfo.page;
+    const pageSize = paginationInfo.pageSize ?? total;
+    return {
+      page,
+      pageSize,
+      pageCount: pageSize > 0 ? Math.ceil(total / pageSize) : 0,
+      total
+    };
+  }
+  if (!fp.isNil(paginationInfo.start)) {
+    const start = paginationInfo.start;
+    const limit = paginationInfo.limit ?? total;
+    return {
+      page: Math.floor(start / limit) + 1,
+      pageSize: limit,
+      pageCount: limit > 0 ? Math.ceil(total / limit) : 0,
+      total
+    };
+  }
+  return {
+    ...paginationInfo,
+    page: 1,
+    pageSize: 10,
+    pageCount: 1,
+    total
+  };
+};
+const transformOffsetPaginationInfo = (paginationInfo, total) => {
+  if (!fp.isNil(paginationInfo.page)) {
+    const limit = paginationInfo.pageSize ?? total;
+    const start = (paginationInfo.page - 1) * limit;
+    return { start, limit, total };
+  }
+  if (!fp.isNil(paginationInfo.start)) {
+    const start = paginationInfo.start;
+    const limit = paginationInfo.limit ?? total;
+    return { start, limit, total };
+  }
+  return {
+    ...paginationInfo,
+    start: 0,
+    limit: 10,
+    total
+  };
+};
 const pagination = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  transformOffsetPaginationInfo,
+  transformPagedPaginationInfo,
   withDefaultPagination
 }, Symbol.toStringTag, { value: "Module" }));
 const SUPPORTED_PACKAGE_MANAGERS = ["npm", "yarn"];
@@ -2772,9 +2921,9 @@ const toRegressedEnumValue = (value) => slugify__default.default(value, {
   separator: "_"
 });
 const getCommonPath = (...paths) => {
-  const [segments, ...otherSegments] = paths.map((it) => ___default.default.split(it, "/"));
-  return ___default.default.join(
-    ___default.default.takeWhile(segments, (str, index2) => otherSegments.every((it) => it[index2] === str)),
+  const [segments, ...otherSegments] = paths.map((it) => ___namespace.default.split(it, "/"));
+  return ___namespace.default.join(
+    ___namespace.default.takeWhile(segments, (str, index2) => otherSegments.every((it) => it[index2] === str)),
     "/"
   );
 };
@@ -2796,7 +2945,7 @@ const joinBy = (joint, ...args) => {
     return url + joint + trim(path);
   }, "");
 };
-const toKebabCase = (value) => _$1.kebabCase(value);
+const toKebabCase = (value) => _.kebabCase(value);
 const strings = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   getCommonPath,
@@ -2816,9 +2965,9 @@ const arrays = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   __proto__: null,
   includesString
 }, Symbol.toStringTag, { value: "Module" }));
-const keysDeep = (obj, path = []) => !___default.default.isObject(obj) ? [path.join(".")] : ___default.default.reduce(
+const keysDeep = (obj, path = []) => !___namespace.default.isObject(obj) ? [path.join(".")] : ___namespace.default.reduce(
   obj,
-  (acc, next, key) => ___default.default.concat(acc, keysDeep(next, [...path, key])),
+  (acc, next, key) => ___namespace.default.concat(acc, keysDeep(next, [...path, key])),
   []
 );
 const objects = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -2882,8 +3031,8 @@ function printValue(value, quoteStrings) {
   );
 }
 const strapiID = () => new StrapiIDSchema();
-const isNotNilTest = (value) => !___default.default.isNil(value);
-const isNotNullTest = (value) => !___default.default.isNull(value);
+const isNotNilTest = (value) => !___namespace.default.isNil(value);
+const isNotNullTest = (value) => !___namespace.default.isNull(value);
 yup__namespace.addMethod(yup__namespace.mixed, "notNil", function isNotNill(msg = "${path} must be defined.") {
   return this.test("defined", msg, isNotNilTest);
 });
@@ -2894,7 +3043,7 @@ yup__namespace.addMethod(yup__namespace.mixed, "isFunction", function isFunction
   return this.test(
     "is a function",
     message,
-    (value) => ___default.default.isUndefined(value) || ___default.default.isFunction(value)
+    (value) => ___namespace.default.isUndefined(value) || ___namespace.default.isFunction(value)
   );
 });
 yup__namespace.addMethod(
@@ -2926,7 +3075,7 @@ yup__namespace.addMethod(
     return this.test(
       "only contains functions",
       message,
-      (value) => ___default.default.isUndefined(value) || value && Object.values(value).every(___default.default.isFunction)
+      (value) => ___namespace.default.isUndefined(value) || value && Object.values(value).every(___namespace.default.isFunction)
     );
   }
 );
@@ -3001,6 +3150,27 @@ const relations = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePro
   isManyToAny,
   isOneToAny
 }, Symbol.toStringTag, { value: "Module" }));
+const validateZod = (schema) => (data) => {
+  try {
+    return schema.parse(data);
+  } catch (error) {
+    if (error instanceof zod.z.ZodError) {
+      const { message, errors: errors2 } = formatZodErrors(error);
+      throw new ValidationError(message, { errors: errors2 });
+    }
+    throw error;
+  }
+};
+const formatZodErrors = (zodError) => ({
+  errors: zodError.errors.map((error) => {
+    return {
+      path: error.path,
+      message: error.message,
+      name: "ValidationError"
+    };
+  }),
+  message: "Validation error"
+});
 exports.arrays = arrays;
 exports.async = async;
 exports.contentTypes = contentTypes;
@@ -3030,5 +3200,6 @@ exports.traverseEntity = traverseEntity$1;
 exports.validate = index;
 exports.validateYupSchema = validateYupSchema;
 exports.validateYupSchemaSync = validateYupSchemaSync;
+exports.validateZod = validateZod;
 exports.yup = yup;
 //# sourceMappingURL=index.js.map