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

package/dist/index.mjs

@@ -1,5 +1,7 @@
-import _$1, { kebabCase } from "lodash";
-import { has, union, getOr, assoc, assign, cloneDeep, remove, eq, curry, isObject, isNil, clone, isArray, isEmpty, toPath, defaults, isString, mergeAll, get, toNumber, isInteger, pick, omit, trim, pipe as pipe$1, split, map as map$1, flatten, first, identity, constant, join, merge, trimChars, trimCharsEnd, trimCharsStart, isNumber } from "lodash/fp";
+import * as _ from "lodash";
+import ___default, { kebabCase } from "lodash";
+import * as dates$1 from "date-fns";
+import { has, union, getOr, assoc, assign, cloneDeep, remove, eq, curry, isObject, isNil, clone, isArray, isEmpty, toPath, defaults, isString, get, toNumber, isInteger, pick, omit, trim, pipe as pipe$1, split, map as map$1, flatten, first, identity, constant, join, merge, trimChars, trimCharsEnd, trimCharsStart, isNumber } from "lodash/fp";
 import { randomUUID } from "crypto";
 import { machineIdSync } from "node-machine-id";
 import * as yup$1 from "yup";
@@ -9,6 +11,7 @@ import execa from "execa";
 import preferredPM from "preferred-pm";
 import { Writable } from "node:stream";
 import slugify from "@sindresorhus/slugify";
+import { z } from "zod";
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {
     const e = m[i];
@@ -28,8 +31,6 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-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);
@@ -128,32 +129,32 @@ const parseType = (options) => {
   }
 };
 function envFn(key, defaultValue) {
-  return _$1.has(process.env, key) ? process.env[key] : defaultValue;
+  return ___default.has(process.env, key) ? process.env[key] : defaultValue;
 }
 function getKey(key) {
   return process.env[key] ?? "";
 }
 const utils = {
   int(key, defaultValue) {
-    if (!_$1.has(process.env, key)) {
+    if (!___default.has(process.env, key)) {
       return defaultValue;
     }
     return parseInt(getKey(key), 10);
   },
   float(key, defaultValue) {
-    if (!_$1.has(process.env, key)) {
+    if (!___default.has(process.env, key)) {
       return defaultValue;
     }
     return parseFloat(getKey(key));
   },
   bool(key, defaultValue) {
-    if (!_$1.has(process.env, key)) {
+    if (!___default.has(process.env, key)) {
       return defaultValue;
     }
     return getKey(key) === "true";
   },
   json(key, defaultValue) {
-    if (!_$1.has(process.env, key)) {
+    if (!___default.has(process.env, key)) {
       return defaultValue;
     }
     try {
@@ -166,7 +167,7 @@ const utils = {
     }
   },
   array(key, defaultValue) {
-    if (!_$1.has(process.env, key)) {
+    if (!___default.has(process.env, key)) {
       return defaultValue;
     }
     let value = getKey(key);
@@ -174,11 +175,11 @@ const utils = {
       value = value.substring(1, value.length - 1);
     }
     return value.split(",").map((v) => {
-      return _$1.trim(_$1.trim(v, " "), '"');
+      return ___default.trim(___default.trim(v, " "), '"');
     });
   },
   date(key, defaultValue) {
-    if (!_$1.has(process.env, key)) {
+    if (!___default.has(process.env, key)) {
       return defaultValue;
     }
     return new Date(getKey(key));
@@ -245,12 +246,12 @@ const getCreatorFields = (model) => {
 const getNonWritableAttributes = (model) => {
   if (!model)
     return [];
-  const nonWritableAttributes = _$1.reduce(
+  const nonWritableAttributes = ___default.reduce(
     model.attributes,
     (acc, attr, attrName) => attr.writable === false ? acc.concat(attrName) : acc,
     []
   );
-  return _$1.uniq([
+  return ___default.uniq([
     ID_ATTRIBUTE$4,
     DOC_ID_ATTRIBUTE$4,
     ...getTimestamps(model),
@@ -260,28 +261,37 @@ const getNonWritableAttributes = (model) => {
 const getWritableAttributes = (model) => {
   if (!model)
     return [];
-  return _$1.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
+  return ___default.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
 };
 const isWritableAttribute = (model, attributeName) => {
   return getWritableAttributes(model).includes(attributeName);
 };
 const getNonVisibleAttributes = (model) => {
-  const nonVisibleAttributes = _$1.reduce(
+  const nonVisibleAttributes = ___default.reduce(
     model.attributes,
     (acc, attr, attrName) => attr.visible === false ? acc.concat(attrName) : acc,
     []
   );
-  return _$1.uniq([ID_ATTRIBUTE$4, DOC_ID_ATTRIBUTE$4, ...getTimestamps(model), ...nonVisibleAttributes]);
+  return ___default.uniq([ID_ATTRIBUTE$4, DOC_ID_ATTRIBUTE$4, ...getTimestamps(model), ...nonVisibleAttributes]);
 };
 const getVisibleAttributes = (model) => {
-  return _$1.difference(_$1.keys(model.attributes), getNonVisibleAttributes(model));
+  return ___default.difference(___default.keys(model.attributes), getNonVisibleAttributes(model));
 };
 const isVisibleAttribute = (model, attributeName) => {
   return getVisibleAttributes(model).includes(attributeName);
 };
-const getOptions = (model) => _$1.assign({ draftAndPublish: false }, _$1.get(model, "options", {}));
-const hasDraftAndPublish = (model) => _$1.get(model, "options.draftAndPublish", false) === true;
-const isDraft = (data, model) => hasDraftAndPublish(model) && _$1.get(data, PUBLISHED_AT_ATTRIBUTE$1) === null;
+const getOptions = (model) => ___default.assign({ draftAndPublish: false }, ___default.get(model, "options", {}));
+const hasDraftAndPublish = (model) => ___default.get(model, "options.draftAndPublish", false) === true;
+const isDraft = (data, model) => hasDraftAndPublish(model) && ___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;
@@ -290,9 +300,9 @@ const getStoredPrivateAttributes = (model) => union(
   getOr([], "options.privateAttributes", model)
 );
 const getPrivateAttributes = (model) => {
-  return _$1.union(
+  return ___default.union(
     getStoredPrivateAttributes(model),
-    _$1.keys(_$1.pickBy(model.attributes, (attr) => !!attr.private))
+    ___default.keys(___default.pickBy(model.attributes, (attr) => !!attr.private))
   );
 };
 const isPrivateAttribute = (model, attributeName) => {
@@ -302,17 +312,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 _$1.reduce(
+  return ___default.reduce(
     schema.attributes,
     (acc, attr, attrName) => {
       if (isComponentAttribute(attr))
@@ -323,7 +338,7 @@ const getComponentAttributes = (schema) => {
   );
 };
 const getScalarAttributes = (schema) => {
-  return _$1.reduce(
+  return ___default.reduce(
     schema.attributes,
     (acc, attr, attrName) => {
       if (isScalarAttribute(attr))
@@ -333,11 +348,22 @@ const getScalarAttributes = (schema) => {
     []
   );
 };
+const getRelationalAttributes = (schema) => {
+  return ___default.reduce(
+    schema.attributes,
+    (acc, attr, attrName) => {
+      if (isRelationalAttribute(attr))
+        acc.push(attrName);
+      return acc;
+    },
+    []
+  );
+};
 const isTypedAttribute = (attribute, type) => {
-  return _$1.has(attribute, "type") && attribute.type === type;
+  return ___default.has(attribute, "type") && attribute.type === type;
 };
 const getContentTypeRoutePrefix = (contentType) => {
-  return isSingleType(contentType) ? _$1.kebabCase(contentType.info.singularName) : _$1.kebabCase(contentType.info.pluralName);
+  return isSingleType(contentType) ? ___default.kebabCase(contentType.info.singularName) : ___default.kebabCase(contentType.info.pluralName);
 };
 const contentTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
@@ -345,17 +371,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,
@@ -364,6 +395,7 @@ const contentTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.define
   isPrivateAttribute,
   isRelationalAttribute,
   isScalarAttribute,
+  isSchema,
   isSingleType,
   isTypedAttribute,
   isVisibleAttribute,
@@ -518,28 +550,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 (!isObject(entity) || isNil(schema)) {
@@ -551,9 +584,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 (isNil(attribute)) {
-      continue;
-    }
     const newPath = { ...path };
     newPath.raw = isNil(path.raw) ? key : `${path.raw}.${key}`;
     if (!isNil(attribute)) {
@@ -566,13 +596,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 (isNil(value)) {
+    if (isNil(value) || 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));
@@ -870,7 +902,7 @@ const convertCountQueryParams = (countQuery) => {
 const convertOrderingQueryParams = (ordering) => {
   return ordering;
 };
-const isPlainObject = (value) => _$1.isPlainObject(value);
+const isPlainObject = (value) => ___default.isPlainObject(value);
 const isStringArray$3 = (value) => isArray(value) && value.every(isString);
 const createTransformer = ({ getModel }) => {
   const convertSortQueryParams = (sortQuery) => {
@@ -903,7 +935,7 @@ const createTransformer = ({ getModel }) => {
       throw new Error("Field cannot be empty");
     }
     validateOrder(order);
-    return _$1.set({}, field, order);
+    return ___default.set({}, field, order);
   };
   const convertNestedSortQueryParam = (sortQuery) => {
     const transformedSort = {};
@@ -921,15 +953,15 @@ const createTransformer = ({ getModel }) => {
     return transformedSort;
   };
   const convertStartQueryParams = (startQuery) => {
-    const startAsANumber = _$1.toNumber(startQuery);
-    if (!_$1.isInteger(startAsANumber) || startAsANumber < 0) {
+    const startAsANumber = ___default.toNumber(startQuery);
+    if (!___default.isInteger(startAsANumber) || startAsANumber < 0) {
       throw new Error(`convertStartQueryParams expected a positive integer got ${startAsANumber}`);
     }
     return startAsANumber;
   };
   const convertLimitQueryParams = (limitQuery) => {
-    const limitAsANumber = _$1.toNumber(limitQuery);
-    if (!_$1.isInteger(limitAsANumber) || limitAsANumber !== -1 && limitAsANumber < 0) {
+    const limitAsANumber = ___default.toNumber(limitQuery);
+    if (!___default.isInteger(limitAsANumber) || limitAsANumber !== -1 && limitAsANumber < 0) {
       throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
     }
     if (limitAsANumber === -1) {
@@ -975,44 +1007,62 @@ const createTransformer = ({ getModel }) => {
       return true;
     }
     if (typeof populate2 === "string") {
-      return populate2.split(",").map((value) => _$1.trim(value));
+      return populate2.split(",").map((value) => ___default.trim(value));
     }
     if (Array.isArray(populate2)) {
-      return _$1.uniq(
+      return ___default.uniq(
         populate2.flatMap((value) => {
           if (typeof value !== "string") {
             throw new InvalidPopulateError();
           }
-          return value.split(",").map((value2) => _$1.trim(value2));
+          return value.split(",").map((value2) => ___default.trim(value2));
         })
       );
     }
-    if (_$1.isPlainObject(populate2)) {
+    if (___default.isPlainObject(populate2)) {
       return convertPopulateObject(populate2, schema);
     }
     throw new InvalidPopulateError();
   };
-  const hasFragmentPopulateDefined = (populate2) => {
+  const hasPopulateFragmentDefined = (populate2) => {
     return typeof populate2 === "object" && "on" in populate2 && !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 (_$1.isBoolean(subPopulate)) {
-        return { ...acc, [key]: subPopulate };
+      if (___default.isString(subPopulate)) {
+        try {
+          const subPopulateAsBoolean = parseType({ type: "boolean", value: subPopulate });
+          return subPopulateAsBoolean === true ? { ...acc, [key]: true } : acc;
+        } catch {
+        }
+      }
+      if (___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,
@@ -1020,21 +1070,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 (isEmpty(populates)) {
-          return acc;
+          });
         }
-        return {
-          ...acc,
-          [key]: 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") {
@@ -1061,10 +1105,10 @@ const createTransformer = ({ getModel }) => {
     }, {});
   };
   const convertNestedPopulate = (subPopulate, schema) => {
-    if (_$1.isString(subPopulate)) {
+    if (___default.isString(subPopulate)) {
       return parseType({ type: "boolean", value: subPopulate, forceCast: true });
     }
-    if (_$1.isBoolean(subPopulate)) {
+    if (___default.isBoolean(subPopulate)) {
       return subPopulate;
     }
     if (!isPlainObject(subPopulate)) {
@@ -1110,12 +1154,12 @@ const createTransformer = ({ getModel }) => {
       return void 0;
     }
     if (typeof fields2 === "string") {
-      const fieldsValues = fields2.split(",").map((value) => _$1.trim(value));
-      return _$1.uniq([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3, ...fieldsValues]);
+      const fieldsValues = fields2.split(",").map((value) => ___default.trim(value));
+      return ___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) => !isNil(v));
-      return _$1.uniq([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3, ...fieldsValues]);
+      return ___default.uniq([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3, ...fieldsValues]);
     }
     throw new Error("Invalid fields parameter. Expected a string or an array of strings");
   };
@@ -1790,7 +1834,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);
@@ -1812,36 +1857,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 (isNil(value)) {
-      return;
-    }
-    if (isObject(value)) {
-      const { components } = attribute;
-      const newValue = {};
-      let newProperties = omit("on", value);
-      for (const componentUID of components) {
-        const componentSchema = getModel(componentUID);
-        const properties = await recurse(
-          visitor2,
-          { schema: componentSchema, path, getModel },
-          value
-        );
-        newProperties = 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 (isNil(value) || !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 = curry(populate.traverse);
 const isStringArray = (value) => isArray(value) && value.every(isString);
 const fields = traverseFactory().intercept(isStringArray, async (visitor2, options, fields2, { recurse }) => {
@@ -2140,13 +2164,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 }) => {
@@ -2155,7 +2182,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"];
@@ -2173,7 +2200,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 });
       }
     }
   };
@@ -2181,7 +2208,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);
@@ -2207,12 +2234,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 } }) => {
@@ -2234,7 +2261,7 @@ const throwDisallowedFields = (allowedFields = null) => ({ key, path: { attribut
   if (isPathAllowed) {
     return;
   }
-  throwInvalidParam({ key, path });
+  throwInvalidKey({ key, path });
 };
 const getContainedPaths = (path) => {
   const parts = toPath(path);
@@ -2244,7 +2271,7 @@ const getContainedPaths = (path) => {
 };
 const throwRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path } }) => {
   if (restrictedFields === null) {
-    throwInvalidParam({ key, path });
+    throwInvalidKey({ key, path });
   }
   if (!(isArray(restrictedFields) && restrictedFields.every(isString))) {
     throw new TypeError(
@@ -2252,14 +2279,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,
@@ -2269,7 +2326,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) => {
@@ -2290,7 +2348,7 @@ const defaultValidateFilters = 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
@@ -2315,7 +2373,7 @@ const defaultValidateSort = curry((ctx, sort2) => {
         return;
       }
       if (!attribute) {
-        throwInvalidParam({ key, path: path.attribute });
+        throwInvalidKey({ key, path: path.attribute });
       }
     }, ctx),
     // dynamic zones from sort
@@ -2332,7 +2390,7 @@ const defaultValidateSort = curry((ctx, sort2) => {
         return;
       }
       if (!isScalarAttribute(attribute) && isEmpty(value)) {
-        throwInvalidParam({ key, path: path.attribute });
+        throwInvalidKey({ key, path: path.attribute });
       }
     }, ctx)
   )(sort2);
@@ -2348,7 +2406,7 @@ const defaultValidateFields = curry((ctx, fields2) => {
         return;
       }
       if (isNil(attribute) || !isScalarAttribute(attribute)) {
-        throwInvalidParam({ key, path: path.attribute });
+        throwInvalidKey({ key, path: path.attribute });
       }
     }, ctx),
     // private fields
@@ -2443,15 +2501,18 @@ const createAPIValidators = (opts) => {
       (data2) => {
         if (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(
@@ -2462,7 +2523,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) {
@@ -2499,7 +2567,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) {
@@ -2514,14 +2590,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) {
@@ -2536,7 +2628,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,
@@ -2620,8 +2720,57 @@ const withDefaultPagination = (args, { defaults: defaults2 = {}, maxLimit = -1 }
   );
   return replacePaginationAttributes(args);
 };
+const transformPagedPaginationInfo = (paginationInfo, total) => {
+  if (!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 (!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 (!isNil(paginationInfo.page)) {
+    const limit = paginationInfo.pageSize ?? total;
+    const start = (paginationInfo.page - 1) * limit;
+    return { start, limit, total };
+  }
+  if (!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"];
@@ -2745,9 +2894,9 @@ const toRegressedEnumValue = (value) => slugify(value, {
   separator: "_"
 });
 const getCommonPath = (...paths) => {
-  const [segments, ...otherSegments] = paths.map((it) => _$1.split(it, "/"));
-  return _$1.join(
-    _$1.takeWhile(segments, (str, index2) => otherSegments.every((it) => it[index2] === str)),
+  const [segments, ...otherSegments] = paths.map((it) => ___default.split(it, "/"));
+  return ___default.join(
+    ___default.takeWhile(segments, (str, index2) => otherSegments.every((it) => it[index2] === str)),
     "/"
   );
 };
@@ -2789,9 +2938,9 @@ const arrays = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   __proto__: null,
   includesString
 }, Symbol.toStringTag, { value: "Module" }));
-const keysDeep = (obj, path = []) => !_$1.isObject(obj) ? [path.join(".")] : _$1.reduce(
+const keysDeep = (obj, path = []) => !___default.isObject(obj) ? [path.join(".")] : ___default.reduce(
   obj,
-  (acc, next, key) => _$1.concat(acc, keysDeep(next, [...path, key])),
+  (acc, next, key) => ___default.concat(acc, keysDeep(next, [...path, key])),
   []
 );
 const objects = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -2855,8 +3004,8 @@ function printValue(value, quoteStrings) {
   );
 }
 const strapiID = () => new StrapiIDSchema();
-const isNotNilTest = (value) => !_$1.isNil(value);
-const isNotNullTest = (value) => !_$1.isNull(value);
+const isNotNilTest = (value) => !___default.isNil(value);
+const isNotNullTest = (value) => !___default.isNull(value);
 yup$1.addMethod(yup$1.mixed, "notNil", function isNotNill(msg = "${path} must be defined.") {
   return this.test("defined", msg, isNotNilTest);
 });
@@ -2867,7 +3016,7 @@ yup$1.addMethod(yup$1.mixed, "isFunction", function isFunction(message = "${path
   return this.test(
     "is a function",
     message,
-    (value) => _$1.isUndefined(value) || _$1.isFunction(value)
+    (value) => ___default.isUndefined(value) || ___default.isFunction(value)
   );
 });
 yup$1.addMethod(
@@ -2899,7 +3048,7 @@ yup$1.addMethod(
     return this.test(
       "only contains functions",
       message,
-      (value) => _$1.isUndefined(value) || value && Object.values(value).every(_$1.isFunction)
+      (value) => ___default.isUndefined(value) || value && Object.values(value).every(___default.isFunction)
     );
   }
 );
@@ -2974,6 +3123,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 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"
+});
 export {
   arrays,
   async,
@@ -3004,6 +3174,7 @@ export {
   index as validate,
   validateYupSchema,
   validateYupSchemaSync,
+  validateZod,
   yup
 };
 //# sourceMappingURL=index.mjs.map