@strapi/utils 5.0.0-alpha.4 → 5.0.0-alpha.6

package/dist/index.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const _$1 = require("lodash");
 const fp = require("lodash/fp");
-const pMap = require("p-map");
-const httpErrors = require("http-errors");
 const crypto = require("crypto");
 const nodeMachineId = require("node-machine-id");
 const yup$1 = require("yup");
+const httpErrors = require("http-errors");
+const pMap = require("p-map");
 const execa = require("execa");
 const preferredPM = require("preferred-pm");
 const node_stream = require("node:stream");
@@ -50,8 +50,8 @@ function _mergeNamespaces(n, m) {
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
 const ___default = /* @__PURE__ */ _interopDefault(_$1);
-const pMap__default = /* @__PURE__ */ _interopDefault(pMap);
 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);
@@ -543,201 +543,32 @@ const providerFactory = (options = {}) => {
     }
   };
 };
-function pipe(...fns) {
-  const [firstFn, ...fnRest] = fns;
-  return async (...args) => {
-    let res = await firstFn.apply(firstFn, args);
-    for (let i = 0; i < fnRest.length; i += 1) {
-      res = await fnRest[i](res);
-    }
-    return res;
+const traverseEntity = async (visitor2, options, entity) => {
+  const { path = { raw: null, attribute: null }, schema, getModel } = options;
+  const traverseMorphRelationTarget = async (visitor22, path2, entry) => {
+    const targetSchema = getModel(entry.__type);
+    const traverseOptions = { schema: targetSchema, path: path2, getModel };
+    return traverseEntity(visitor22, traverseOptions, entry);
   };
-}
-const map = fp.curry(pMap__default.default);
-const reduce = (mixedArray) => async (iteratee, initialValue) => {
-  let acc = initialValue;
-  for (let i = 0; i < mixedArray.length; i += 1) {
-    acc = await iteratee(acc, await mixedArray[i], i);
-  }
-  return acc;
-};
-const async = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  map,
-  pipe,
-  reduce
-}, Symbol.toStringTag, { value: "Module" }));
-const visitor$8 = ({ key, attribute }, { remove }) => {
-  if (attribute?.type === "password") {
-    remove(key);
-  }
-};
-const visitor$7 = ({ schema, key, attribute }, { remove }) => {
-  if (!attribute) {
-    return;
-  }
-  const isPrivate = attribute.private === true || isPrivateAttribute(schema, key);
-  if (isPrivate) {
-    remove(key);
-  }
-};
-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 }, { remove, set }) => {
-  if (!attribute) {
-    return;
-  }
-  const isRelation = attribute.type === "relation";
-  if (!isRelation) {
-    return;
-  }
-  const handleMorphRelation = async () => {
-    const newMorphValue = [];
-    for (const element of data[key]) {
-      const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${element.__type}.${action}`);
-      const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
-      if (isAllowed) {
-        newMorphValue.push(element);
-      }
-    }
-    if (newMorphValue.length === 0) {
-      remove(key);
-    } else {
-      set(key, newMorphValue);
-    }
+  const traverseRelationTarget = (schema2) => async (visitor22, path2, entry) => {
+    const traverseOptions = { schema: schema2, path: path2, getModel };
+    return traverseEntity(visitor22, traverseOptions, entry);
   };
-  const handleRegularRelation = async () => {
-    const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${attribute.target}.${action}`);
-    const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
-    if (!isAllowed) {
-      remove(key);
-    }
+  const traverseMediaTarget = async (visitor22, path2, entry) => {
+    const targetSchemaUID = "plugin::upload.file";
+    const targetSchema = getModel(targetSchemaUID);
+    const traverseOptions = { schema: targetSchema, path: path2, getModel };
+    return traverseEntity(visitor22, traverseOptions, entry);
+  };
+  const traverseComponent = async (visitor22, path2, schema2, entry) => {
+    const traverseOptions = { schema: schema2, path: path2, getModel };
+    return traverseEntity(visitor22, traverseOptions, entry);
+  };
+  const visitDynamicZoneEntry = async (visitor22, path2, entry) => {
+    const targetSchema = getModel(entry.__component);
+    const traverseOptions = { schema: targetSchema, path: path2, getModel };
+    return traverseEntity(visitor22, traverseOptions, entry);
   };
-  const isCreatorRelation = [CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE$1].includes(key);
-  if (isMorphToRelationalAttribute(attribute)) {
-    await handleMorphRelation();
-    return;
-  }
-  if (isCreatorRelation && schema.options?.populateCreatorFields) {
-    return;
-  }
-  await handleRegularRelation();
-};
-const hasAccessToSomeScopes$1 = async (scopes, auth) => {
-  for (const scope of scopes) {
-    try {
-      await strapi.auth.verify(auth, { scope });
-      return true;
-    } catch {
-      continue;
-    }
-  }
-  return false;
-};
-const visitor$6 = ({ key, attribute }, { remove }) => {
-  if (isMorphToRelationalAttribute(attribute)) {
-    remove(key);
-  }
-};
-const visitor$5 = ({ key, attribute }, { remove }) => {
-  if (isDynamicZoneAttribute(attribute)) {
-    remove(key);
-  }
-};
-const removeDisallowedFields = (allowedFields = null) => ({ key, path: { attribute: path } }, { 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}"`
-    );
-  }
-  if (fp.isNil(path)) {
-    return;
-  }
-  const containedPaths = getContainedPaths$1(path);
-  const isPathAllowed = allowedFields.some(
-    (p) => containedPaths.includes(p) || p.startsWith(`${path}.`)
-  );
-  if (isPathAllowed) {
-    return;
-  }
-  remove(key);
-};
-const getContainedPaths$1 = (path) => {
-  const parts = fp.toPath(path);
-  return parts.reduce((acc, value, index2, list) => {
-    return [...acc, list.slice(0, index2 + 1).join(".")];
-  }, []);
-};
-const removeRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path } }, { remove }) => {
-  if (restrictedFields === null) {
-    remove(key);
-    return;
-  }
-  if (!(fp.isArray(restrictedFields) && restrictedFields.every(fp.isString))) {
-    throw new TypeError(
-      `Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`
-    );
-  }
-  if (restrictedFields.includes(path)) {
-    remove(key);
-    return;
-  }
-  const isRestrictedNested = restrictedFields.some(
-    (allowedPath) => path?.toString().startsWith(`${allowedPath}.`)
-  );
-  if (isRestrictedNested) {
-    remove(key);
-  }
-};
-const visitor$4 = ({ schema, key, value }, { set }) => {
-  if (key === "" && value === "*") {
-    const { attributes } = schema;
-    const newPopulateQuery = Object.entries(attributes).filter(
-      ([, attribute]) => ["relation", "component", "media", "dynamiczone"].includes(attribute.type)
-    ).reduce((acc, [key2]) => ({ ...acc, [key2]: true }), {});
-    set("", newPopulateQuery);
-  }
-};
-const visitors$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  expandWildcardPopulate: visitor$4,
-  removeDisallowedFields,
-  removeDynamicZones: visitor$5,
-  removeMorphToRelations: visitor$6,
-  removePassword: visitor$8,
-  removePrivate: visitor$7,
-  removeRestrictedFields,
-  removeRestrictedRelations
-}, Symbol.toStringTag, { value: "Module" }));
-const traverseMorphRelationTarget = async (visitor2, path, entry) => {
-  const targetSchema = strapi.getModel(entry.__type);
-  const traverseOptions = { schema: targetSchema, path };
-  return traverseEntity(visitor2, traverseOptions, entry);
-};
-const traverseRelationTarget = (schema) => async (visitor2, path, entry) => {
-  const traverseOptions = { schema, path };
-  return traverseEntity(visitor2, traverseOptions, entry);
-};
-const traverseMediaTarget = async (visitor2, path, entry) => {
-  const targetSchemaUID = "plugin::upload.file";
-  const targetSchema = strapi.getModel(targetSchemaUID);
-  const traverseOptions = { schema: targetSchema, path };
-  return traverseEntity(visitor2, traverseOptions, entry);
-};
-const traverseComponent = async (visitor2, path, schema, entry) => {
-  const traverseOptions = { schema, path };
-  return traverseEntity(visitor2, traverseOptions, entry);
-};
-const visitDynamicZoneEntry = async (visitor2, path, entry) => {
-  const targetSchema = strapi.getModel(entry.__component);
-  const traverseOptions = { schema: targetSchema, path };
-  return traverseEntity(visitor2, traverseOptions, entry);
-};
-const traverseEntity = async (visitor2, options, entity) => {
-  const { path = { raw: null, attribute: null }, schema } = options;
   if (!fp.isObject(entity) || fp.isNil(schema)) {
     return entity;
   }
@@ -761,7 +592,8 @@ const traverseEntity = async (visitor2, options, entity) => {
       key,
       value: copy[key],
       attribute,
-      path: newPath
+      path: newPath,
+      getModel
     };
     await visitor2(visitorOptions, visitorUtils);
     const value = copy[key];
@@ -770,7 +602,7 @@ const traverseEntity = async (visitor2, options, entity) => {
     }
     if (isRelationalAttribute(attribute)) {
       const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
-      const method = isMorphRelation ? traverseMorphRelationTarget : traverseRelationTarget(strapi.getModel(attribute.target));
+      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) {
@@ -795,7 +627,7 @@ const traverseEntity = async (visitor2, options, entity) => {
       continue;
     }
     if (attribute.type === "component") {
-      const targetSchema = strapi.getModel(attribute.component);
+      const targetSchema = getModel(attribute.component);
       if (fp.isArray(value)) {
         const res = new Array(value.length);
         for (let i2 = 0; i2 < value.length; i2 += 1) {
@@ -827,87 +659,860 @@ const createVisitorUtils = ({ data }) => ({
   }
 });
 const traverseEntity$1 = fp.curry(traverseEntity);
-const DEFAULT_PATH = { raw: null, attribute: null };
-const traverseFactory = () => {
-  const state = {
-    parsers: [],
-    interceptors: [],
-    ignore: [],
-    handlers: {
-      attributes: [],
-      common: []
-    }
-  };
-  const traverse = async (visitor2, options, data) => {
-    const { path = DEFAULT_PATH, schema } = options ?? {};
-    for (const { predicate, handler } of state.interceptors) {
-      if (predicate(data)) {
-        return handler(visitor2, options, data, { recurse: traverse });
-      }
-    }
-    const parser = state.parsers.find((parser2) => parser2.predicate(data))?.parser;
-    const utils2 = parser?.(data);
-    if (!utils2) {
-      return data;
-    }
-    let out = utils2.transform(data);
-    const keys = utils2.keys(out);
-    for (const key of keys) {
-      const attribute = schema?.attributes?.[key] ?? // FIX: Needed to not break existing behavior on the API.
-      //      It looks for the attribute in the DB metadata when the key is in snake_case
-      schema?.attributes?.[strapi.db.metadata.get(schema?.uid).columnToAttribute[key]];
-      const newPath = { ...path };
-      newPath.raw = fp.isNil(path.raw) ? key : `${path.raw}.${key}`;
-      if (!fp.isNil(attribute)) {
-        newPath.attribute = fp.isNil(path.attribute) ? key : `${path.attribute}.${key}`;
-      }
-      const visitorOptions = {
-        key,
-        value: utils2.get(key, out),
-        attribute,
-        schema,
-        path: newPath,
-        data: out
-      };
-      const transformUtils = {
-        remove(key2) {
-          out = utils2.remove(key2, out);
-        },
-        set(key2, value2) {
-          out = utils2.set(key2, value2, out);
-        },
-        recurse: traverse
-      };
-      await visitor2(visitorOptions, fp.pick(["remove", "set"], transformUtils));
-      const value = utils2.get(key, out);
-      const createContext = () => ({
-        key,
-        value,
-        attribute,
-        schema,
-        path: newPath,
-        data: out,
-        visitor: visitor2
-      });
-      const ignoreCtx = createContext();
-      const shouldIgnore = state.ignore.some((predicate) => predicate(ignoreCtx));
-      if (shouldIgnore) {
-        continue;
-      }
-      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));
-        }
-      }
-    }
-    return out;
-  };
-  return {
-    traverse,
-    intercept(predicate, handler) {
+function importDefault(modName) {
+  const mod = require(modName);
+  return mod && mod.__esModule ? mod.default : mod;
+}
+const machineId = () => {
+  try {
+    const deviceId = nodeMachineId.machineIdSync();
+    return deviceId;
+  } catch (error) {
+    const deviceId = crypto.randomUUID();
+    return deviceId;
+  }
+};
+const formatYupInnerError = (yupError) => ({
+  path: fp.toPath(yupError.path),
+  message: yupError.message,
+  name: yupError.name
+});
+const formatYupErrors = (yupError) => ({
+  errors: fp.isEmpty(yupError.inner) ? [formatYupInnerError(yupError)] : yupError.inner.map(formatYupInnerError),
+  message: yupError.message
+});
+class ApplicationError extends Error {
+  name;
+  details;
+  message;
+  constructor(message = "An application error occured", details = {}) {
+    super();
+    this.name = "ApplicationError";
+    this.message = message;
+    this.details = details;
+  }
+}
+class ValidationError extends ApplicationError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "ValidationError";
+  }
+}
+class YupValidationError extends ValidationError {
+  constructor(yupError, message) {
+    super("Validation");
+    const { errors: errors2, message: yupMessage } = formatYupErrors(yupError);
+    this.message = message || yupMessage;
+    this.details = { errors: errors2 };
+  }
+}
+class PaginationError extends ApplicationError {
+  constructor(message = "Invalid pagination", details) {
+    super(message, details);
+    this.name = "PaginationError";
+    this.message = message;
+  }
+}
+class NotFoundError extends ApplicationError {
+  constructor(message = "Entity not found", details) {
+    super(message, details);
+    this.name = "NotFoundError";
+    this.message = message;
+  }
+}
+class ForbiddenError extends ApplicationError {
+  constructor(message = "Forbidden access", details) {
+    super(message, details);
+    this.name = "ForbiddenError";
+    this.message = message;
+  }
+}
+class UnauthorizedError extends ApplicationError {
+  constructor(message = "Unauthorized", details) {
+    super(message, details);
+    this.name = "UnauthorizedError";
+    this.message = message;
+  }
+}
+class RateLimitError extends ApplicationError {
+  constructor(message = "Too many requests, please try again later.", details) {
+    super(message, details);
+    this.name = "RateLimitError";
+    this.message = message;
+    this.details = details || {};
+  }
+}
+class PayloadTooLargeError extends ApplicationError {
+  constructor(message = "Entity too large", details) {
+    super(message, details);
+    this.name = "PayloadTooLargeError";
+    this.message = message;
+  }
+}
+class PolicyError extends ForbiddenError {
+  constructor(message = "Policy Failed", details) {
+    super(message, details);
+    this.name = "PolicyError";
+    this.message = message;
+    this.details = details || {};
+  }
+}
+class NotImplementedError extends ApplicationError {
+  constructor(message = "This feature is not implemented yet", details) {
+    super(message, details);
+    this.name = "NotImplementedError";
+    this.message = message;
+  }
+}
+const errors = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ApplicationError,
+  ForbiddenError,
+  HttpError: httpErrors.HttpError,
+  NotFoundError,
+  NotImplementedError,
+  PaginationError,
+  PayloadTooLargeError,
+  PolicyError,
+  RateLimitError,
+  UnauthorizedError,
+  ValidationError,
+  YupValidationError
+}, Symbol.toStringTag, { value: "Module" }));
+const handleYupError = (error, errorMessage) => {
+  throw new YupValidationError(error, errorMessage);
+};
+const defaultValidationParam = { strict: true, abortEarly: false };
+const validateYupSchema = (schema, options = {}) => async (body, errorMessage) => {
+  try {
+    const optionsWithDefaults = fp.defaults(defaultValidationParam, options);
+    const result = await schema.validate(body, optionsWithDefaults);
+    return result;
+  } catch (e) {
+    if (e instanceof yup__namespace.ValidationError) {
+      handleYupError(e, errorMessage);
+    }
+    throw e;
+  }
+};
+const validateYupSchemaSync = (schema, options = {}) => (body, errorMessage) => {
+  try {
+    const optionsWithDefaults = fp.defaults(defaultValidationParam, options);
+    return schema.validateSync(body, optionsWithDefaults);
+  } catch (e) {
+    if (e instanceof yup__namespace.ValidationError) {
+      handleYupError(e, errorMessage);
+    }
+    throw e;
+  }
+};
+const GROUP_OPERATORS = ["$and", "$or"];
+const WHERE_OPERATORS = [
+  "$not",
+  "$in",
+  "$notIn",
+  "$eq",
+  "$eqi",
+  "$ne",
+  "$nei",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$null",
+  "$notNull",
+  "$between",
+  "$startsWith",
+  "$endsWith",
+  "$startsWithi",
+  "$endsWithi",
+  "$contains",
+  "$notContains",
+  "$containsi",
+  "$notContainsi",
+  // Experimental, only for internal use
+  "$jsonSupersetOf"
+];
+const CAST_OPERATORS = [
+  "$not",
+  "$in",
+  "$notIn",
+  "$eq",
+  "$ne",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$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 isObjKey = (key, obj) => {
+  return key in obj;
+};
+const isOperatorOfType = (type, key, ignoreCase = false) => {
+  if (ignoreCase) {
+    return OPERATORS_LOWERCASE[type]?.includes(key.toLowerCase()) ?? false;
+  }
+  if (isObjKey(type, OPERATORS)) {
+    return OPERATORS[type]?.includes(key) ?? false;
+  }
+  return false;
+};
+const isOperator = (key, ignoreCase = false) => {
+  return Object.keys(OPERATORS).some((type) => isOperatorOfType(type, key, ignoreCase));
+};
+const { ID_ATTRIBUTE: ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$3, PUBLISHED_AT_ATTRIBUTE } = constants$1;
+class InvalidOrderError extends Error {
+  constructor() {
+    super();
+    this.message = "Invalid order. order can only be one of asc|desc|ASC|DESC";
+  }
+}
+class InvalidSortError extends Error {
+  constructor() {
+    super();
+    this.message = "Invalid sort parameter. Expected a string, an array of strings, a sort object or an array of sort objects";
+  }
+}
+function validateOrder(order) {
+  if (!fp.isString(order) || !["asc", "desc"].includes(order.toLocaleLowerCase())) {
+    throw new InvalidOrderError();
+  }
+}
+const convertCountQueryParams = (countQuery) => {
+  return parseType({ type: "boolean", value: countQuery });
+};
+const convertOrderingQueryParams = (ordering) => {
+  return ordering;
+};
+const isPlainObject = (value) => ___default.default.isPlainObject(value);
+const isStringArray$3 = (value) => fp.isArray(value) && value.every(fp.isString);
+const createTransformer = ({ getModel }) => {
+  const convertSortQueryParams = (sortQuery) => {
+    if (typeof sortQuery === "string") {
+      return convertStringSortQueryParam(sortQuery);
+    }
+    if (isStringArray$3(sortQuery)) {
+      return sortQuery.flatMap((sortValue) => convertStringSortQueryParam(sortValue));
+    }
+    if (Array.isArray(sortQuery)) {
+      return sortQuery.map((sortValue) => convertNestedSortQueryParam(sortValue));
+    }
+    if (isPlainObject(sortQuery)) {
+      return convertNestedSortQueryParam(sortQuery);
+    }
+    throw new InvalidSortError();
+  };
+  const convertStringSortQueryParam = (sortQuery) => {
+    return sortQuery.split(",").map((value) => convertSingleSortQueryParam(value));
+  };
+  const convertSingleSortQueryParam = (sortQuery) => {
+    if (!sortQuery) {
+      return {};
+    }
+    if (!fp.isString(sortQuery)) {
+      throw new Error("Invalid sort query");
+    }
+    const [field, order = "asc"] = sortQuery.split(":");
+    if (field.length === 0) {
+      throw new Error("Field cannot be empty");
+    }
+    validateOrder(order);
+    return ___default.default.set({}, field, order);
+  };
+  const convertNestedSortQueryParam = (sortQuery) => {
+    const transformedSort = {};
+    for (const field of Object.keys(sortQuery)) {
+      const order = sortQuery[field];
+      if (isPlainObject(order)) {
+        transformedSort[field] = convertNestedSortQueryParam(order);
+      } else if (typeof order === "string") {
+        validateOrder(order);
+        transformedSort[field] = order;
+      } else {
+        throw Error(`Invalid sort type expected object or string got ${typeof order}`);
+      }
+    }
+    return transformedSort;
+  };
+  const convertStartQueryParams = (startQuery) => {
+    const startAsANumber = ___default.default.toNumber(startQuery);
+    if (!___default.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) {
+      throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
+    }
+    if (limitAsANumber === -1) {
+      return void 0;
+    }
+    return limitAsANumber;
+  };
+  const convertPageQueryParams = (page) => {
+    const pageVal = fp.toNumber(page);
+    if (!fp.isInteger(pageVal) || pageVal <= 0) {
+      throw new PaginationError(
+        `Invalid 'page' parameter. Expected an integer > 0, received: ${page}`
+      );
+    }
+    return pageVal;
+  };
+  const convertPageSizeQueryParams = (pageSize, page) => {
+    const pageSizeVal = fp.toNumber(pageSize);
+    if (!fp.isInteger(pageSizeVal) || pageSizeVal <= 0) {
+      throw new PaginationError(
+        `Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`
+      );
+    }
+    return pageSizeVal;
+  };
+  const validatePaginationParams = (page, pageSize, start, limit) => {
+    const isPagePagination = !fp.isNil(page) || !fp.isNil(pageSize);
+    const isOffsetPagination = !fp.isNil(start) || !fp.isNil(limit);
+    if (isPagePagination && isOffsetPagination) {
+      throw new PaginationError(
+        "Invalid pagination attributes. You cannot use page and offset pagination in the same query"
+      );
+    }
+  };
+  class InvalidPopulateError extends Error {
+    constructor() {
+      super();
+      this.message = "Invalid populate parameter. Expected a string, an array of strings, a populate object";
+    }
+  }
+  const convertPopulateQueryParams = (populate2, schema, depth = 0) => {
+    if (depth === 0 && populate2 === "*") {
+      return true;
+    }
+    if (typeof populate2 === "string") {
+      return populate2.split(",").map((value) => ___default.default.trim(value));
+    }
+    if (Array.isArray(populate2)) {
+      return ___default.default.uniq(
+        populate2.flatMap((value) => {
+          if (typeof value !== "string") {
+            throw new InvalidPopulateError();
+          }
+          return value.split(",").map((value2) => ___default.default.trim(value2));
+        })
+      );
+    }
+    if (___default.default.isPlainObject(populate2)) {
+      return convertPopulateObject(populate2, schema);
+    }
+    throw new InvalidPopulateError();
+  };
+  const hasFragmentPopulateDefined = (populate2) => {
+    return typeof populate2 === "object" && "on" in populate2 && !fp.isNil(populate2.on);
+  };
+  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 };
+      }
+      const attribute = attributes[key];
+      if (!attribute) {
+        return acc;
+      }
+      const isAllowedAttributeForFragmentPopulate = isDynamicZoneAttribute(attribute) || isMorphToRelationalAttribute(attribute);
+      if (isAllowedAttributeForFragmentPopulate && hasFragmentPopulateDefined(subPopulate)) {
+        return {
+          ...acc,
+          [key]: {
+            on: Object.entries(subPopulate.on).reduce(
+              (acc2, [type, typeSubPopulate]) => ({
+                ...acc2,
+                [type]: convertNestedPopulate(typeSubPopulate, getModel(type))
+              }),
+              {}
+            )
+          }
+        };
+      }
+      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 (isMorphToRelationalAttribute(attribute)) {
+        return { ...acc, [key]: convertNestedPopulate(subPopulate, void 0) };
+      }
+      let targetSchemaUID;
+      if (attribute.type === "relation") {
+        targetSchemaUID = attribute.target;
+      } else if (attribute.type === "component") {
+        targetSchemaUID = attribute.component;
+      } else if (attribute.type === "media") {
+        targetSchemaUID = "plugin::upload.file";
+      } else {
+        return acc;
+      }
+      const targetSchema = getModel(targetSchemaUID);
+      if (!targetSchema) {
+        return acc;
+      }
+      const populateObject = convertNestedPopulate(subPopulate, targetSchema);
+      if (!populateObject) {
+        return acc;
+      }
+      return {
+        ...acc,
+        [key]: populateObject
+      };
+    }, {});
+  };
+  const convertNestedPopulate = (subPopulate, schema) => {
+    if (___default.default.isString(subPopulate)) {
+      return parseType({ type: "boolean", value: subPopulate, forceCast: true });
+    }
+    if (___default.default.isBoolean(subPopulate)) {
+      return subPopulate;
+    }
+    if (!isPlainObject(subPopulate)) {
+      throw new Error(`Invalid nested populate. Expected '*' or an object`);
+    }
+    const { sort: sort2, filters: filters2, fields: fields2, populate: populate2, count, ordering, page, pageSize, start, limit } = subPopulate;
+    const query = {};
+    if (sort2) {
+      query.orderBy = convertSortQueryParams(sort2);
+    }
+    if (filters2) {
+      query.where = convertFiltersQueryParams(filters2, schema);
+    }
+    if (fields2) {
+      query.select = convertFieldsQueryParams(fields2);
+    }
+    if (populate2) {
+      query.populate = convertPopulateQueryParams(populate2, schema);
+    }
+    if (count) {
+      query.count = convertCountQueryParams(count);
+    }
+    if (ordering) {
+      query.ordering = convertOrderingQueryParams(ordering);
+    }
+    validatePaginationParams(page, pageSize, start, limit);
+    if (!fp.isNil(page)) {
+      query.page = convertPageQueryParams(page);
+    }
+    if (!fp.isNil(pageSize)) {
+      query.pageSize = convertPageSizeQueryParams(pageSize, page);
+    }
+    if (!fp.isNil(start)) {
+      query.offset = convertStartQueryParams(start);
+    }
+    if (!fp.isNil(limit)) {
+      query.limit = convertLimitQueryParams(limit);
+    }
+    return query;
+  };
+  const convertFieldsQueryParams = (fields2, depth = 0) => {
+    if (depth === 0 && fields2 === "*") {
+      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]);
+    }
+    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]);
+    }
+    throw new Error("Invalid fields parameter. Expected a string or an array of strings");
+  };
+  const isValidSchemaAttribute = (key, schema) => {
+    if ([DOC_ID_ATTRIBUTE$3, ID_ATTRIBUTE$3].includes(key)) {
+      return true;
+    }
+    if (!schema) {
+      return false;
+    }
+    return Object.keys(schema.attributes).includes(key);
+  };
+  const convertFiltersQueryParams = (filters2, schema) => {
+    if (!fp.isObject(filters2)) {
+      throw new Error("The filters parameter must be an object or an array");
+    }
+    const filtersCopy = fp.cloneDeep(filters2);
+    return convertAndSanitizeFilters(filtersCopy, schema);
+  };
+  const convertAndSanitizeFilters = (filters2, schema) => {
+    if (Array.isArray(filters2)) {
+      return filters2.map((filter) => convertAndSanitizeFilters(filter, schema)).filter((filter) => !isPlainObject(filter) || !fp.isEmpty(filter));
+    }
+    if (!isPlainObject(filters2)) {
+      return filters2;
+    }
+    const removeOperator = (operator) => delete filters2[operator];
+    for (const [key, value] of Object.entries(filters2)) {
+      const attribute = fp.get(key, schema?.attributes);
+      const validKey = isOperator(key) || isValidSchemaAttribute(key, schema);
+      if (!validKey) {
+        removeOperator(key);
+      } else if (attribute) {
+        if (attribute.type === "relation") {
+          filters2[key] = convertAndSanitizeFilters(value, getModel(attribute.target));
+        } else if (attribute.type === "component") {
+          filters2[key] = convertAndSanitizeFilters(value, getModel(attribute.component));
+        } else if (attribute.type === "media") {
+          filters2[key] = convertAndSanitizeFilters(value, getModel("plugin::upload.file"));
+        } else if (attribute.type === "dynamiczone") {
+          removeOperator(key);
+        } else if (attribute.type === "password") {
+          removeOperator(key);
+        } else {
+          filters2[key] = convertAndSanitizeFilters(value, schema);
+        }
+      } else if (["$null", "$notNull"].includes(key)) {
+        filters2[key] = parseType({ type: "boolean", value: filters2[key], forceCast: true });
+      } else if (fp.isObject(value)) {
+        filters2[key] = convertAndSanitizeFilters(value, schema);
+      }
+      if (isPlainObject(filters2[key]) && fp.isEmpty(filters2[key])) {
+        removeOperator(key);
+      }
+    }
+    return filters2;
+  };
+  const convertStatusParams = (status, query = {}) => {
+    query.filters = ({ meta }) => {
+      const contentType = getModel(meta.uid);
+      if (!contentType || !hasDraftAndPublish(contentType)) {
+        return {};
+      }
+      return { [PUBLISHED_AT_ATTRIBUTE]: { $null: status === "draft" } };
+    };
+  };
+  const transformQueryParams = (uid, params) => {
+    const schema = getModel(uid);
+    const query = {};
+    const { _q, sort: sort2, filters: filters2, fields: fields2, populate: populate2, page, pageSize, start, limit, status, ...rest } = params;
+    if (!fp.isNil(status)) {
+      convertStatusParams(status, query);
+    }
+    if (!fp.isNil(_q)) {
+      query._q = _q;
+    }
+    if (!fp.isNil(sort2)) {
+      query.orderBy = convertSortQueryParams(sort2);
+    }
+    if (!fp.isNil(filters2)) {
+      query.where = convertFiltersQueryParams(filters2, schema);
+    }
+    if (!fp.isNil(fields2)) {
+      query.select = convertFieldsQueryParams(fields2);
+    }
+    if (!fp.isNil(populate2)) {
+      query.populate = convertPopulateQueryParams(populate2, schema);
+    }
+    validatePaginationParams(page, pageSize, start, limit);
+    if (!fp.isNil(page)) {
+      query.page = convertPageQueryParams(page);
+    }
+    if (!fp.isNil(pageSize)) {
+      query.pageSize = convertPageSizeQueryParams(pageSize, page);
+    }
+    if (!fp.isNil(start)) {
+      query.offset = convertStartQueryParams(start);
+    }
+    if (!fp.isNil(limit)) {
+      query.limit = convertLimitQueryParams(limit);
+    }
+    return {
+      ...rest,
+      ...query
+    };
+  };
+  return {
+    private_convertSortQueryParams: convertSortQueryParams,
+    private_convertStartQueryParams: convertStartQueryParams,
+    private_convertLimitQueryParams: convertLimitQueryParams,
+    private_convertPopulateQueryParams: convertPopulateQueryParams,
+    private_convertFiltersQueryParams: convertFiltersQueryParams,
+    private_convertFieldsQueryParams: convertFieldsQueryParams,
+    transformQueryParams
+  };
+};
+const convertQueryParams = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createTransformer
+}, Symbol.toStringTag, { value: "Module" }));
+function pipe(...fns) {
+  const [firstFn, ...fnRest] = fns;
+  return async (...args) => {
+    let res = await firstFn.apply(firstFn, args);
+    for (let i = 0; i < fnRest.length; i += 1) {
+      res = await fnRest[i](res);
+    }
+    return res;
+  };
+}
+const map = fp.curry(pMap__default.default);
+const reduce = (mixedArray) => async (iteratee, initialValue) => {
+  let acc = initialValue;
+  for (let i = 0; i < mixedArray.length; i += 1) {
+    acc = await iteratee(acc, await mixedArray[i], i);
+  }
+  return acc;
+};
+const async = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  map,
+  pipe,
+  reduce
+}, Symbol.toStringTag, { value: "Module" }));
+const visitor$8 = ({ key, attribute }, { remove }) => {
+  if (attribute?.type === "password") {
+    remove(key);
+  }
+};
+const visitor$7 = ({ schema, key, attribute }, { remove }) => {
+  if (!attribute) {
+    return;
+  }
+  const isPrivate = attribute.private === true || isPrivateAttribute(schema, key);
+  if (isPrivate) {
+    remove(key);
+  }
+};
+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 }, { remove, set }) => {
+  if (!attribute) {
+    return;
+  }
+  const isRelation = attribute.type === "relation";
+  if (!isRelation) {
+    return;
+  }
+  const handleMorphRelation = async () => {
+    const newMorphValue = [];
+    for (const element of data[key]) {
+      const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${element.__type}.${action}`);
+      const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
+      if (isAllowed) {
+        newMorphValue.push(element);
+      }
+    }
+    if (newMorphValue.length === 0) {
+      remove(key);
+    } else {
+      set(key, newMorphValue);
+    }
+  };
+  const handleRegularRelation = async () => {
+    const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${attribute.target}.${action}`);
+    const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
+    if (!isAllowed) {
+      remove(key);
+    }
+  };
+  const isCreatorRelation = [CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE$1].includes(key);
+  if (isMorphToRelationalAttribute(attribute)) {
+    await handleMorphRelation();
+    return;
+  }
+  if (isCreatorRelation && schema.options?.populateCreatorFields) {
+    return;
+  }
+  await handleRegularRelation();
+};
+const hasAccessToSomeScopes$1 = async (scopes, auth) => {
+  for (const scope of scopes) {
+    try {
+      await strapi.auth.verify(auth, { scope });
+      return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+};
+const visitor$6 = ({ key, attribute }, { remove }) => {
+  if (isMorphToRelationalAttribute(attribute)) {
+    remove(key);
+  }
+};
+const visitor$5 = ({ key, attribute }, { remove }) => {
+  if (isDynamicZoneAttribute(attribute)) {
+    remove(key);
+  }
+};
+const removeDisallowedFields = (allowedFields = null) => ({ key, path: { attribute: path } }, { 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}"`
+    );
+  }
+  if (fp.isNil(path)) {
+    return;
+  }
+  const containedPaths = getContainedPaths$1(path);
+  const isPathAllowed = allowedFields.some(
+    (p) => containedPaths.includes(p) || p.startsWith(`${path}.`)
+  );
+  if (isPathAllowed) {
+    return;
+  }
+  remove(key);
+};
+const getContainedPaths$1 = (path) => {
+  const parts = fp.toPath(path);
+  return parts.reduce((acc, value, index2, list) => {
+    return [...acc, list.slice(0, index2 + 1).join(".")];
+  }, []);
+};
+const removeRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path } }, { remove }) => {
+  if (restrictedFields === null) {
+    remove(key);
+    return;
+  }
+  if (!(fp.isArray(restrictedFields) && restrictedFields.every(fp.isString))) {
+    throw new TypeError(
+      `Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`
+    );
+  }
+  if (restrictedFields.includes(path)) {
+    remove(key);
+    return;
+  }
+  const isRestrictedNested = restrictedFields.some(
+    (allowedPath) => path?.toString().startsWith(`${allowedPath}.`)
+  );
+  if (isRestrictedNested) {
+    remove(key);
+  }
+};
+const visitor$4 = ({ schema, key, value }, { set }) => {
+  if (key === "" && value === "*") {
+    const { attributes } = schema;
+    const newPopulateQuery = Object.entries(attributes).filter(
+      ([, attribute]) => ["relation", "component", "media", "dynamiczone"].includes(attribute.type)
+    ).reduce((acc, [key2]) => ({ ...acc, [key2]: true }), {});
+    set("", newPopulateQuery);
+  }
+};
+const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  expandWildcardPopulate: visitor$4,
+  removeDisallowedFields,
+  removeDynamicZones: visitor$5,
+  removeMorphToRelations: visitor$6,
+  removePassword: visitor$8,
+  removePrivate: visitor$7,
+  removeRestrictedFields,
+  removeRestrictedRelations
+}, Symbol.toStringTag, { value: "Module" }));
+const DEFAULT_PATH = { raw: null, attribute: null };
+const traverseFactory = () => {
+  const state = {
+    parsers: [],
+    interceptors: [],
+    ignore: [],
+    handlers: {
+      attributes: [],
+      common: []
+    }
+  };
+  const traverse = async (visitor2, options, data) => {
+    const { path = DEFAULT_PATH, schema, getModel } = options ?? {};
+    for (const { predicate, handler } of state.interceptors) {
+      if (predicate(data)) {
+        return handler(visitor2, options, data, { recurse: traverse });
+      }
+    }
+    const parser = state.parsers.find((parser2) => parser2.predicate(data))?.parser;
+    const utils2 = parser?.(data);
+    if (!utils2) {
+      return data;
+    }
+    let out = utils2.transform(data);
+    const keys = utils2.keys(out);
+    for (const key of keys) {
+      const attribute = schema?.attributes?.[key];
+      const newPath = { ...path };
+      newPath.raw = fp.isNil(path.raw) ? key : `${path.raw}.${key}`;
+      if (!fp.isNil(attribute)) {
+        newPath.attribute = fp.isNil(path.attribute) ? key : `${path.attribute}.${key}`;
+      }
+      const visitorOptions = {
+        key,
+        value: utils2.get(key, out),
+        attribute,
+        schema,
+        path: newPath,
+        data: out,
+        getModel
+      };
+      const transformUtils = {
+        remove(key2) {
+          out = utils2.remove(key2, out);
+        },
+        set(key2, value2) {
+          out = utils2.set(key2, value2, out);
+        },
+        recurse: traverse
+      };
+      await visitor2(visitorOptions, fp.pick(["remove", "set"], transformUtils));
+      const value = utils2.get(key, out);
+      const createContext = () => ({
+        key,
+        value,
+        attribute,
+        schema,
+        path: newPath,
+        data: out,
+        visitor: visitor2,
+        getModel
+      });
+      const ignoreCtx = createContext();
+      const shouldIgnore = state.ignore.some((predicate) => predicate(ignoreCtx));
+      if (shouldIgnore) {
+        continue;
+      }
+      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));
+        }
+      }
+    }
+    return out;
+  };
+  return {
+    traverse,
+    intercept(predicate, handler) {
       state.interceptors.push({ predicate, handler });
       return this;
     },
@@ -976,33 +1581,33 @@ const filters = traverseFactory().intercept(
   }
 })).ignore(({ value }) => fp.isNil(value)).on(
   ({ attribute }) => fp.isNil(attribute),
-  async ({ key, visitor: visitor2, path, value, schema }, { set, recurse }) => {
-    set(key, await recurse(visitor2, { schema, path }, value));
+  async ({ key, visitor: visitor2, path, value, schema, getModel }, { set, recurse }) => {
+    set(key, await recurse(visitor2, { schema, path, getModel }, value));
   }
-).onRelation(async ({ key, attribute, visitor: visitor2, path, value }, { set, recurse }) => {
+).onRelation(async ({ key, attribute, visitor: visitor2, path, value, getModel }, { set, recurse }) => {
   const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
   if (isMorphRelation) {
     return;
   }
   const targetSchemaUID = attribute.target;
-  const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  const targetSchema = getModel(targetSchemaUID);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
   set(key, newValue);
-}).onComponent(async ({ key, attribute, visitor: visitor2, path, value }, { set, recurse }) => {
-  const targetSchema = strapi.getModel(attribute.component);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+}).onComponent(async ({ key, attribute, visitor: visitor2, path, value, getModel }, { set, recurse }) => {
+  const targetSchema = getModel(attribute.component);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
   set(key, newValue);
-}).onMedia(async ({ key, visitor: visitor2, path, value }, { set, recurse }) => {
+}).onMedia(async ({ key, visitor: visitor2, path, value, getModel }, { set, recurse }) => {
   const targetSchemaUID = "plugin::upload.file";
-  const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  const targetSchema = getModel(targetSchemaUID);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
   set(key, newValue);
 });
 const 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$3 = (value) => Array.isArray(value) && value.every(fp.isString);
+const isStringArray$2 = (value) => Array.isArray(value) && value.every(fp.isString);
 const isObjectArray = (value) => Array.isArray(value) && value.every(fp.isObject);
 const isNestedSorts = (value) => fp.isString(value) && value.split(",").length > 1;
 const isObj$1 = (value) => fp.isObject(value);
@@ -1016,7 +1621,7 @@ const sort = traverseFactory().intercept(
   }
 ).intercept(
   // Array of strings ['foo', 'foo,bar'] => map(recurse), then filter out empty items
-  isStringArray$3,
+  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))
@@ -1083,23 +1688,23 @@ const sort = traverseFactory().intercept(
   get(key, data) {
     return data[key];
   }
-})).onRelation(async ({ key, value, attribute, visitor: visitor2, path }, { set, recurse }) => {
+})).onRelation(async ({ key, value, attribute, visitor: visitor2, path, getModel }, { set, recurse }) => {
   const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
   if (isMorphRelation) {
     return;
   }
   const targetSchemaUID = attribute.target;
-  const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  const targetSchema = getModel(targetSchemaUID);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
   set(key, newValue);
-}).onMedia(async ({ key, path, visitor: visitor2, value }, { recurse, set }) => {
+}).onMedia(async ({ key, path, visitor: visitor2, value, getModel }, { recurse, set }) => {
   const targetSchemaUID = "plugin::upload.file";
-  const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  const targetSchema = getModel(targetSchemaUID);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
   set(key, newValue);
-}).onComponent(async ({ key, value, visitor: visitor2, path, attribute }, { recurse, set }) => {
-  const targetSchema = strapi.getModel(attribute.component);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+}).onComponent(async ({ key, value, visitor: visitor2, path, attribute, getModel }, { recurse, set }) => {
+  const targetSchema = getModel(attribute.component);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
   set(key, newValue);
 });
 const traverseQuerySort = fp.curry(sort.traverse);
@@ -1108,9 +1713,9 @@ const isKeyword = (keyword) => {
     return !attribute && keyword === key;
   };
 };
-const isStringArray$2 = (value) => fp.isArray(value) && value.every(fp.isString);
+const isStringArray$1 = (value) => fp.isArray(value) && value.every(fp.isString);
 const isObj = (value) => fp.isObject(value);
-const populate = traverseFactory().intercept(isStringArray$2, async (visitor2, options, populate2, { recurse }) => {
+const populate = traverseFactory().intercept(isStringArray$1, async (visitor2, options, populate2, { recurse }) => {
   const visitedPopulate = await Promise.all(
     populate2.map((nestedPopulate) => recurse(visitor2, options, nestedPopulate))
   );
@@ -1187,78 +1792,86 @@ const populate = traverseFactory().intercept(isStringArray$2, async (visitor2, o
 }).on(
   // Handle recursion on populate."populate"
   isKeyword("populate"),
-  async ({ key, visitor: visitor2, path, value, schema }, { set, recurse }) => {
-    const newValue = await recurse(visitor2, { schema, path }, value);
+  async ({ key, visitor: visitor2, path, value, schema, getModel }, { set, recurse }) => {
+    const newValue = await recurse(visitor2, { schema, path, getModel }, value);
     set(key, newValue);
   }
-).on(isKeyword("on"), async ({ key, visitor: visitor2, path, value }, { set, recurse }) => {
+).on(isKeyword("on"), async ({ key, visitor: visitor2, path, value, getModel }, { set, recurse }) => {
   const newOn = {};
   if (!isObj(value)) {
     return;
   }
   for (const [uid, subPopulate] of Object.entries(value)) {
-    const model = strapi.getModel(uid);
+    const model = getModel(uid);
     const newPath = { ...path, raw: `${path.raw}[${uid}]` };
-    newOn[uid] = await recurse(visitor2, { schema: model, path: newPath }, subPopulate);
+    newOn[uid] = await recurse(visitor2, { schema: model, path: newPath, getModel }, subPopulate);
   }
   set(key, newOn);
-}).onRelation(async ({ key, value, attribute, visitor: visitor2, path, schema }, { set, recurse }) => {
-  if (fp.isNil(value)) {
-    return;
-  }
-  if (isMorphToRelationalAttribute(attribute)) {
-    if (!fp.isObject(value) || !("on" in value && fp.isObject(value?.on))) {
+}).onRelation(
+  async ({ key, value, attribute, visitor: visitor2, path, schema, getModel }, { set, recurse }) => {
+    if (fp.isNil(value)) {
       return;
     }
-    const newValue2 = await recurse(visitor2, { schema, path }, { on: value?.on });
-    set(key, { on: newValue2 });
+    if (isMorphToRelationalAttribute(attribute)) {
+      if (!fp.isObject(value) || !("on" in value && fp.isObject(value?.on))) {
+        return;
+      }
+      const newValue2 = await recurse(visitor2, { schema, path, getModel }, { on: value?.on });
+      set(key, { on: newValue2 });
+    }
+    const targetSchemaUID = attribute.target;
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
+    set(key, newValue);
   }
-  const targetSchemaUID = attribute.target;
-  const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
-  set(key, newValue);
-}).onMedia(async ({ key, path, visitor: visitor2, value }, { recurse, set }) => {
+).onMedia(async ({ key, path, visitor: visitor2, value, getModel }, { recurse, set }) => {
   if (fp.isNil(value)) {
     return;
   }
   const targetSchemaUID = "plugin::upload.file";
-  const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  const targetSchema = getModel(targetSchemaUID);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path, getModel }, value);
   set(key, newValue);
-}).onComponent(async ({ key, value, visitor: visitor2, path, attribute }, { recurse, set }) => {
+}).onComponent(async ({ key, value, visitor: visitor2, path, attribute, getModel }, { recurse, set }) => {
   if (fp.isNil(value)) {
     return;
   }
-  const targetSchema = strapi.getModel(attribute.component);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  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 }, { 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 = strapi.getModel(componentUID);
-      const properties = await recurse(visitor2, { schema: componentSchema, path }, value);
-      newProperties = fp.merge(newProperties, properties);
+}).onDynamicZone(
+  async ({ key, value, attribute, schema, visitor: visitor2, path, getModel }, { set, recurse }) => {
+    if (fp.isNil(value)) {
+      return;
     }
-    Object.assign(newValue, newProperties);
-    if ("on" in value && value.on) {
-      const newOn = await recurse(visitor2, { schema, path }, { on: value.on });
-      Object.assign(newValue, newOn);
+    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);
     }
-    set(key, newValue);
-  } else {
-    const newValue = await recurse(visitor2, { schema, path }, value);
-    set(key, newValue);
   }
-});
+);
 const traverseQueryPopulate = fp.curry(populate.traverse);
-const isStringArray$1 = (value) => fp.isArray(value) && value.every(fp.isString);
-const fields = traverseFactory().intercept(isStringArray$1, async (visitor2, options, fields2, { recurse }) => {
+const isStringArray = (value) => 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.eq("*", value), fp.constant("*")).parse(fp.isString, () => ({
   transform: fp.trim,
@@ -1276,90 +1889,22 @@ const fields = traverseFactory().intercept(isStringArray$1, async (visitor2, opt
   }
 }));
 const traverseQueryFields = fp.curry(fields.traverse);
-const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  factory: traverseFactory,
   traverseQueryFields,
   traverseQueryFilters,
   traverseQueryPopulate,
   traverseQuerySort
 }, Symbol.toStringTag, { value: "Module" }));
-const GROUP_OPERATORS = ["$and", "$or"];
-const WHERE_OPERATORS = [
-  "$not",
-  "$in",
-  "$notIn",
-  "$eq",
-  "$eqi",
-  "$ne",
-  "$nei",
-  "$gt",
-  "$gte",
-  "$lt",
-  "$lte",
-  "$null",
-  "$notNull",
-  "$between",
-  "$startsWith",
-  "$endsWith",
-  "$startsWithi",
-  "$endsWithi",
-  "$contains",
-  "$notContains",
-  "$containsi",
-  "$notContainsi",
-  // Experimental, only for internal use
-  "$jsonSupersetOf"
-];
-const CAST_OPERATORS = [
-  "$not",
-  "$in",
-  "$notIn",
-  "$eq",
-  "$ne",
-  "$gt",
-  "$gte",
-  "$lt",
-  "$lte",
-  "$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 isObjKey = (key, obj) => {
-  return key in obj;
-};
-const isOperatorOfType = (type, key, ignoreCase = false) => {
-  if (ignoreCase) {
-    return OPERATORS_LOWERCASE[type]?.includes(key.toLowerCase()) ?? false;
-  }
-  if (isObjKey(type, OPERATORS)) {
-    return OPERATORS[type]?.includes(key) ?? false;
-  }
-  return false;
-};
-const isOperator = (key, ignoreCase = false) => {
-  return Object.keys(OPERATORS).some((type) => isOperatorOfType(type, key, ignoreCase));
-};
-const { ID_ATTRIBUTE: ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$3 } = constants$1;
-const sanitizePasswords = (schema) => async (entity) => {
-  if (!schema) {
+const { ID_ATTRIBUTE: ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$2 } = constants$1;
+const sanitizePasswords = (ctx) => async (entity) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in sanitizePasswords");
   }
-  return traverseEntity$1(visitor$8, { schema }, entity);
+  return traverseEntity$1(visitor$8, ctx, entity);
 };
-const defaultSanitizeOutput = async (schema, entity) => {
-  if (!schema) {
+const defaultSanitizeOutput = async (ctx, entity) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultSanitizeOutput");
   }
   return traverseEntity$1(
@@ -1367,139 +1912,121 @@ const defaultSanitizeOutput = async (schema, entity) => {
       visitor$8(...args);
       visitor$7(...args);
     },
-    { schema },
+    ctx,
     entity
   );
 };
-const defaultSanitizeFilters = fp.curry((schema, filters2) => {
-  if (!schema) {
+const defaultSanitizeFilters = fp.curry((ctx, filters2) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultSanitizeFilters");
   }
   return pipe(
     // Remove keys that are not attributes or valid operators
-    traverseQueryFilters(
-      ({ key, attribute }, { remove }) => {
-        const isAttribute = !!attribute;
-        if ([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3].includes(key)) {
-          return;
-        }
-        if (!isAttribute && !isOperator(key)) {
-          remove(key);
-        }
-      },
-      { schema }
-    ),
+    traverseQueryFilters(({ key, attribute }, { remove }) => {
+      const isAttribute = !!attribute;
+      if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
+        return;
+      }
+      if (!isAttribute && !isOperator(key)) {
+        remove(key);
+      }
+    }, ctx),
     // Remove dynamic zones from filters
-    traverseQueryFilters(visitor$5, { schema }),
+    traverseQueryFilters(visitor$5, ctx),
     // Remove morpTo relations from filters
-    traverseQueryFilters(visitor$6, { schema }),
+    traverseQueryFilters(visitor$6, ctx),
     // Remove passwords from filters
-    traverseQueryFilters(visitor$8, { schema }),
+    traverseQueryFilters(visitor$8, ctx),
     // Remove private from filters
-    traverseQueryFilters(visitor$7, { schema }),
+    traverseQueryFilters(visitor$7, ctx),
     // Remove empty objects
-    traverseQueryFilters(
-      ({ key, value }, { remove }) => {
-        if (fp.isObject(value) && fp.isEmpty(value)) {
-          remove(key);
-        }
-      },
-      { schema }
-    )
+    traverseQueryFilters(({ key, value }, { remove }) => {
+      if (fp.isObject(value) && fp.isEmpty(value)) {
+        remove(key);
+      }
+    }, ctx)
   )(filters2);
 });
-const defaultSanitizeSort = fp.curry((schema, sort2) => {
-  if (!schema) {
+const defaultSanitizeSort = fp.curry((ctx, sort2) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultSanitizeSort");
   }
   return pipe(
     // Remove non attribute keys
-    traverseQuerySort(
-      ({ key, attribute }, { remove }) => {
-        if ([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3].includes(key)) {
-          return;
-        }
-        if (!attribute) {
-          remove(key);
-        }
-      },
-      { schema }
-    ),
+    traverseQuerySort(({ key, attribute }, { remove }) => {
+      if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
+        return;
+      }
+      if (!attribute) {
+        remove(key);
+      }
+    }, ctx),
     // Remove dynamic zones from sort
-    traverseQuerySort(visitor$5, { schema }),
+    traverseQuerySort(visitor$5, ctx),
     // Remove morpTo relations from sort
-    traverseQuerySort(visitor$6, { schema }),
+    traverseQuerySort(visitor$6, ctx),
     // Remove private from sort
-    traverseQuerySort(visitor$7, { schema }),
+    traverseQuerySort(visitor$7, ctx),
     // Remove passwords from filters
-    traverseQuerySort(visitor$8, { schema }),
+    traverseQuerySort(visitor$8, ctx),
     // Remove keys for empty non-scalar values
-    traverseQuerySort(
-      ({ key, attribute, value }, { remove }) => {
-        if ([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3].includes(key)) {
-          return;
-        }
-        if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
-          remove(key);
-        }
-      },
-      { schema }
-    )
+    traverseQuerySort(({ key, attribute, value }, { remove }) => {
+      if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
+        return;
+      }
+      if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
+        remove(key);
+      }
+    }, ctx)
   )(sort2);
 });
-const defaultSanitizeFields = fp.curry((schema, fields2) => {
-  if (!schema) {
+const defaultSanitizeFields = fp.curry((ctx, fields2) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultSanitizeFields");
   }
   return pipe(
     // Only keep scalar attributes
-    traverseQueryFields(
-      ({ key, attribute }, { remove }) => {
-        if ([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3].includes(key)) {
-          return;
-        }
-        if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
-          remove(key);
-        }
-      },
-      { schema }
-    ),
+    traverseQueryFields(({ key, attribute }, { remove }) => {
+      if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
+        return;
+      }
+      if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
+        remove(key);
+      }
+    }, ctx),
     // Remove private fields
-    traverseQueryFields(visitor$7, { schema }),
+    traverseQueryFields(visitor$7, ctx),
     // Remove password fields
-    traverseQueryFields(visitor$8, { schema }),
+    traverseQueryFields(visitor$8, ctx),
     // Remove nil values from fields array
     (value) => fp.isArray(value) ? value.filter((field) => !fp.isNil(field)) : value
   )(fields2);
 });
-const defaultSanitizePopulate = fp.curry((schema, populate2) => {
-  if (!schema) {
+const defaultSanitizePopulate = fp.curry((ctx, populate2) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultSanitizePopulate");
   }
   return pipe(
-    traverseQueryPopulate(visitor$4, { schema }),
-    traverseQueryPopulate(
-      async ({ key, value, schema: schema2, attribute }, { set }) => {
-        if (attribute) {
-          return;
-        }
-        if (key === "sort") {
-          set(key, await defaultSanitizeSort(schema2, value));
-        }
-        if (key === "filters") {
-          set(key, await defaultSanitizeFilters(schema2, value));
-        }
-        if (key === "fields") {
-          set(key, await defaultSanitizeFields(schema2, value));
-        }
-        if (key === "populate") {
-          set(key, await defaultSanitizePopulate(schema2, value));
-        }
-      },
-      { schema }
-    ),
+    traverseQueryPopulate(visitor$4, ctx),
+    traverseQueryPopulate(async ({ key, value, schema, attribute, getModel }, { set }) => {
+      if (attribute) {
+        return;
+      }
+      if (key === "sort") {
+        set(key, await defaultSanitizeSort({ schema, getModel }, value));
+      }
+      if (key === "filters") {
+        set(key, await defaultSanitizeFilters({ schema, getModel }, value));
+      }
+      if (key === "fields") {
+        set(key, await defaultSanitizeFields({ schema, getModel }, value));
+      }
+      if (key === "populate") {
+        set(key, await defaultSanitizePopulate({ schema, getModel }, value));
+      }
+    }, ctx),
     // Remove private fields
-    traverseQueryPopulate(visitor$7, { schema })
+    traverseQueryPopulate(visitor$7, ctx)
   )(populate2);
 });
 const sanitizers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -1511,7 +2038,8 @@ const sanitizers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   defaultSanitizeSort,
   sanitizePasswords
 }, Symbol.toStringTag, { value: "Module" }));
-const createContentAPISanitizers = () => {
+const createAPISanitizers = (opts) => {
+  const { getModel } = opts;
   const sanitizeInput = (data, schema, { auth } = {}) => {
     if (!schema) {
       throw new Error("Missing schema in sanitizeInput");
@@ -1525,12 +2053,14 @@ const createContentAPISanitizers = () => {
       fp.omit(constants$1.ID_ATTRIBUTE),
       fp.omit(constants$1.DOC_ID_ATTRIBUTE),
       // Remove non-writable attributes
-      traverseEntity$1(removeRestrictedFields(nonWritableAttributes), { schema })
+      traverseEntity$1(removeRestrictedFields(nonWritableAttributes), { schema, getModel })
     ];
     if (auth) {
-      transforms.push(traverseEntity$1(removeRestrictedRelations(auth), { schema }));
+      transforms.push(
+        traverseEntity$1(removeRestrictedRelations(auth), { schema, getModel })
+      );
     }
-    strapi.sanitizers.get("content-api.input").forEach((sanitizer) => transforms.push(sanitizer(schema)));
+    opts?.sanitizers?.input?.forEach((sanitizer) => transforms.push(sanitizer(schema)));
     return pipe(...transforms)(data);
   };
   const sanitizeOutput = async (data, schema, { auth } = {}) => {
@@ -1544,11 +2074,15 @@ const createContentAPISanitizers = () => {
       }
       return res;
     }
-    const transforms = [(data2) => defaultSanitizeOutput(schema, data2)];
+    const transforms = [
+      (data2) => defaultSanitizeOutput({ schema, getModel }, data2)
+    ];
     if (auth) {
-      transforms.push(traverseEntity$1(removeRestrictedRelations(auth), { schema }));
+      transforms.push(
+        traverseEntity$1(removeRestrictedRelations(auth), { schema, getModel })
+      );
     }
-    strapi.sanitizers.get("content-api.output").forEach((sanitizer) => transforms.push(sanitizer(schema)));
+    opts?.sanitizers?.output?.forEach((sanitizer) => transforms.push(sanitizer(schema)));
     return pipe(...transforms)(data);
   };
   const sanitizeQuery = async (query, schema, { auth } = {}) => {
@@ -1578,9 +2112,11 @@ const createContentAPISanitizers = () => {
     if (fp.isArray(filters2)) {
       return Promise.all(filters2.map((filter) => sanitizeFilters(filter, schema, { auth })));
     }
-    const transforms = [defaultSanitizeFilters(schema)];
+    const transforms = [defaultSanitizeFilters({ schema, getModel })];
     if (auth) {
-      transforms.push(traverseQueryFilters(removeRestrictedRelations(auth), { schema }));
+      transforms.push(
+        traverseQueryFilters(removeRestrictedRelations(auth), { schema, getModel })
+      );
     }
     return pipe(...transforms)(filters2);
   };
@@ -1588,9 +2124,11 @@ const createContentAPISanitizers = () => {
     if (!schema) {
       throw new Error("Missing schema in sanitizeSort");
     }
-    const transforms = [defaultSanitizeSort(schema)];
+    const transforms = [defaultSanitizeSort({ schema, getModel })];
     if (auth) {
-      transforms.push(traverseQuerySort(removeRestrictedRelations(auth), { schema }));
+      transforms.push(
+        traverseQuerySort(removeRestrictedRelations(auth), { schema, getModel })
+      );
     }
     return pipe(...transforms)(sort2);
   };
@@ -1598,16 +2136,18 @@ const createContentAPISanitizers = () => {
     if (!schema) {
       throw new Error("Missing schema in sanitizeFields");
     }
-    const transforms = [defaultSanitizeFields(schema)];
+    const transforms = [defaultSanitizeFields({ schema, getModel })];
     return pipe(...transforms)(fields2);
   };
   const sanitizePopulate = (populate2, schema, { auth } = {}) => {
     if (!schema) {
       throw new Error("Missing schema in sanitizePopulate");
     }
-    const transforms = [defaultSanitizePopulate(schema)];
+    const transforms = [defaultSanitizePopulate({ schema, getModel })];
     if (auth) {
-      transforms.push(traverseQueryPopulate(removeRestrictedRelations(auth), { schema }));
+      transforms.push(
+        traverseQueryPopulate(removeRestrictedRelations(auth), { schema, getModel })
+      );
     }
     return pipe(...transforms)(populate2);
   };
@@ -1621,118 +2161,11 @@ const createContentAPISanitizers = () => {
     populate: sanitizePopulate
   };
 };
-const contentAPI$1 = createContentAPISanitizers();
-const index$1 = {
-  contentAPI: contentAPI$1,
-  sanitizers,
-  visitors: visitors$1
-};
-const formatYupInnerError = (yupError) => ({
-  path: fp.toPath(yupError.path),
-  message: yupError.message,
-  name: yupError.name
-});
-const formatYupErrors = (yupError) => ({
-  errors: fp.isEmpty(yupError.inner) ? [formatYupInnerError(yupError)] : yupError.inner.map(formatYupInnerError),
-  message: yupError.message
-});
-class ApplicationError extends Error {
-  name;
-  details;
-  message;
-  constructor(message = "An application error occured", details = {}) {
-    super();
-    this.name = "ApplicationError";
-    this.message = message;
-    this.details = details;
-  }
-}
-class ValidationError extends ApplicationError {
-  constructor(message, details) {
-    super(message, details);
-    this.name = "ValidationError";
-  }
-}
-class YupValidationError extends ValidationError {
-  constructor(yupError, message) {
-    super("Validation");
-    const { errors: errors2, message: yupMessage } = formatYupErrors(yupError);
-    this.message = message || yupMessage;
-    this.details = { errors: errors2 };
-  }
-}
-class PaginationError extends ApplicationError {
-  constructor(message = "Invalid pagination", details) {
-    super(message, details);
-    this.name = "PaginationError";
-    this.message = message;
-  }
-}
-class NotFoundError extends ApplicationError {
-  constructor(message = "Entity not found", details) {
-    super(message, details);
-    this.name = "NotFoundError";
-    this.message = message;
-  }
-}
-class ForbiddenError extends ApplicationError {
-  constructor(message = "Forbidden access", details) {
-    super(message, details);
-    this.name = "ForbiddenError";
-    this.message = message;
-  }
-}
-class UnauthorizedError extends ApplicationError {
-  constructor(message = "Unauthorized", details) {
-    super(message, details);
-    this.name = "UnauthorizedError";
-    this.message = message;
-  }
-}
-class RateLimitError extends ApplicationError {
-  constructor(message = "Too many requests, please try again later.", details) {
-    super(message, details);
-    this.name = "RateLimitError";
-    this.message = message;
-    this.details = details || {};
-  }
-}
-class PayloadTooLargeError extends ApplicationError {
-  constructor(message = "Entity too large", details) {
-    super(message, details);
-    this.name = "PayloadTooLargeError";
-    this.message = message;
-  }
-}
-class PolicyError extends ForbiddenError {
-  constructor(message = "Policy Failed", details) {
-    super(message, details);
-    this.name = "PolicyError";
-    this.message = message;
-    this.details = details || {};
-  }
-}
-class NotImplementedError extends ApplicationError {
-  constructor(message = "This feature is not implemented yet", details) {
-    super(message, details);
-    this.name = "NotImplementedError";
-    this.message = message;
-  }
-}
-const errors = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ApplicationError,
-  ForbiddenError,
-  HttpError: httpErrors.HttpError,
-  NotFoundError,
-  NotImplementedError,
-  PaginationError,
-  PayloadTooLargeError,
-  PolicyError,
-  RateLimitError,
-  UnauthorizedError,
-  ValidationError,
-  YupValidationError
+  createAPISanitizers,
+  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}`;
@@ -1855,7 +2288,7 @@ const throwRestrictedFields = (restrictedFields = null) => ({ key, path: { attri
     throwInvalidParam({ key, path });
   }
 };
-const visitors = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   throwDisallowedFields,
   throwDynamicZones: visitor,
@@ -1865,131 +2298,152 @@ const visitors = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   throwRestrictedFields,
   throwRestrictedRelations
 }, Symbol.toStringTag, { value: "Module" }));
-const { ID_ATTRIBUTE: ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$2 } = constants$1;
-const throwPasswords = (schema) => async (entity) => {
-  if (!schema) {
+const { ID_ATTRIBUTE: ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$1 } = constants$1;
+const throwPasswords = (ctx) => async (entity) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in throwPasswords");
   }
-  return traverseEntity$1(visitor$3, { schema }, entity);
+  return traverseEntity$1(visitor$3, ctx, entity);
 };
-const defaultValidateFilters = fp.curry((schema, filters2) => {
-  if (!schema) {
+const defaultValidateFilters = fp.curry((ctx, filters2) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultValidateFilters");
   }
   return pipe(
     // keys that are not attributes or valid operators
-    traverseQueryFilters(
-      ({ key, attribute, path }) => {
-        if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
-          return;
-        }
-        const isAttribute = !!attribute;
-        if (!isAttribute && !isOperator(key)) {
-          throwInvalidParam({ key, path: path.attribute });
-        }
-      },
-      { schema }
-    ),
+    traverseQueryFilters(({ key, attribute, path }) => {
+      if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
+        return;
+      }
+      const isAttribute = !!attribute;
+      if (!isAttribute && !isOperator(key)) {
+        throwInvalidParam({ key, path: path.attribute });
+      }
+    }, ctx),
     // dynamic zones from filters
-    traverseQueryFilters(visitor, { schema }),
+    traverseQueryFilters(visitor, ctx),
     // morphTo relations from filters; because you can't have deep filtering on morph relations
-    traverseQueryFilters(visitor$1, { schema }),
+    traverseQueryFilters(visitor$1, ctx),
     // passwords from filters
-    traverseQueryFilters(visitor$3, { schema }),
+    traverseQueryFilters(visitor$3, ctx),
     // private from filters
-    traverseQueryFilters(visitor$2, { schema })
+    traverseQueryFilters(visitor$2, ctx)
     // we allow empty objects to validate and only sanitize them out, so that users may write "lazy" queries without checking their params exist
   )(filters2);
 });
-const defaultValidateSort = fp.curry((schema, sort2) => {
-  if (!schema) {
+const defaultValidateSort = fp.curry((ctx, sort2) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultValidateSort");
   }
   return pipe(
     // non attribute keys
-    traverseQuerySort(
-      ({ key, attribute, path }) => {
-        if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
-          return;
-        }
-        if (!attribute) {
-          throwInvalidParam({ key, path: path.attribute });
-        }
-      },
-      { schema }
-    ),
+    traverseQuerySort(({ key, attribute, path }) => {
+      if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
+        return;
+      }
+      if (!attribute) {
+        throwInvalidParam({ key, path: path.attribute });
+      }
+    }, ctx),
     // dynamic zones from sort
-    traverseQuerySort(visitor, { schema }),
+    traverseQuerySort(visitor, ctx),
     // morphTo relations from sort
-    traverseQuerySort(visitor$1, { schema }),
+    traverseQuerySort(visitor$1, ctx),
     // private from sort
-    traverseQuerySort(visitor$2, { schema }),
+    traverseQuerySort(visitor$2, ctx),
     // passwords from filters
-    traverseQuerySort(visitor$3, { schema }),
+    traverseQuerySort(visitor$3, ctx),
     // keys for empty non-scalar values
-    traverseQuerySort(
-      ({ key, attribute, value, path }) => {
-        if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
-          return;
-        }
-        if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
-          throwInvalidParam({ key, path: path.attribute });
-        }
-      },
-      { schema }
-    )
+    traverseQuerySort(({ key, attribute, value, path }) => {
+      if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
+        return;
+      }
+      if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
+        throwInvalidParam({ key, path: path.attribute });
+      }
+    }, ctx)
   )(sort2);
 });
-const defaultValidateFields = fp.curry((schema, fields2) => {
-  if (!schema) {
+const defaultValidateFields = fp.curry((ctx, fields2) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultValidateFields");
   }
   return pipe(
     // Only allow scalar attributes
-    traverseQueryFields(
-      ({ key, attribute, path }) => {
-        if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
-          return;
-        }
-        if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
-          throwInvalidParam({ key, path: path.attribute });
-        }
-      },
-      { schema }
-    ),
+    traverseQueryFields(({ key, attribute, path }) => {
+      if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
+        return;
+      }
+      if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
+        throwInvalidParam({ key, path: path.attribute });
+      }
+    }, ctx),
     // private fields
-    traverseQueryFields(visitor$2, { schema }),
+    traverseQueryFields(visitor$2, ctx),
     // password fields
-    traverseQueryFields(visitor$3, { schema })
+    traverseQueryFields(visitor$3, ctx)
   )(fields2);
 });
-const defaultValidatePopulate = fp.curry((schema, populate2) => {
-  if (!schema) {
+const defaultValidatePopulate = fp.curry((ctx, populate2) => {
+  if (!ctx.schema) {
     throw new Error("Missing schema in defaultValidatePopulate");
   }
   return pipe(
-    traverseQueryPopulate(
-      async ({ key, value, schema: schema2, attribute }, { set }) => {
-        if (attribute) {
-          return;
-        }
-        if (key === "sort") {
-          set(key, await defaultValidateSort(schema2, value));
-        }
-        if (key === "filters") {
-          set(key, await defaultValidateFilters(schema2, value));
-        }
-        if (key === "fields") {
-          set(key, await defaultValidateFields(schema2, value));
-        }
-        if (key === "populate") {
-          set(key, await defaultValidatePopulate(schema2, value));
-        }
-      },
-      { schema }
-    ),
+    traverseQueryPopulate(async ({ key, value, schema, attribute, getModel }, { set }) => {
+      if (attribute) {
+        return;
+      }
+      if (key === "sort") {
+        set(
+          key,
+          await defaultValidateSort(
+            {
+              schema,
+              getModel
+            },
+            value
+          )
+        );
+      }
+      if (key === "filters") {
+        set(
+          key,
+          await defaultValidateFilters(
+            {
+              schema,
+              getModel
+            },
+            value
+          )
+        );
+      }
+      if (key === "fields") {
+        set(
+          key,
+          await defaultValidateFields(
+            {
+              schema,
+              getModel
+            },
+            value
+          )
+        );
+      }
+      if (key === "populate") {
+        set(
+          key,
+          await defaultValidatePopulate(
+            {
+              schema,
+              getModel
+            },
+            value
+          )
+        );
+      }
+    }, ctx),
     // Remove private fields
-    traverseQueryPopulate(visitor$2, { schema })
+    traverseQueryPopulate(visitor$2, ctx)
   )(populate2);
 });
 const validators = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -2000,8 +2454,9 @@ const validators = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   defaultValidateSort,
   throwPasswords
 }, Symbol.toStringTag, { value: "Module" }));
-const { ID_ATTRIBUTE: ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$1 } = constants$1;
-const createContentAPIValidators = () => {
+const { ID_ATTRIBUTE, DOC_ID_ATTRIBUTE } = constants$1;
+const createAPIValidators = (opts) => {
+  const { getModel } = opts || {};
   const validateInput = async (data, schema, { auth } = {}) => {
     if (!schema) {
       throw new Error("Missing schema in validateInput");
@@ -2014,21 +2469,26 @@ const createContentAPIValidators = () => {
     const transforms = [
       (data2) => {
         if (fp.isObject(data2)) {
-          if (ID_ATTRIBUTE$1 in data2) {
-            throwInvalidParam({ key: ID_ATTRIBUTE$1 });
+          if (ID_ATTRIBUTE in data2) {
+            throwInvalidParam({ key: ID_ATTRIBUTE });
           }
-          if (DOC_ID_ATTRIBUTE$1 in data2) {
-            throwInvalidParam({ key: DOC_ID_ATTRIBUTE$1 });
+          if (DOC_ID_ATTRIBUTE in data2) {
+            throwInvalidParam({ key: DOC_ID_ATTRIBUTE });
           }
         }
       },
       // non-writable attributes
-      traverseEntity$1(throwRestrictedFields(nonWritableAttributes), { schema })
+      traverseEntity$1(throwRestrictedFields(nonWritableAttributes), { schema, getModel })
     ];
     if (auth) {
-      transforms.push(traverseEntity$1(throwRestrictedRelations(auth), { schema }));
-    }
-    strapi.validators.get("content-api.input").forEach((validator) => transforms.push(validator(schema)));
+      transforms.push(
+        traverseEntity$1(throwRestrictedRelations(auth), {
+          schema,
+          getModel
+        })
+      );
+    }
+    opts?.validators?.input?.forEach((validator) => transforms.push(validator(schema)));
     await pipe(...transforms)(data);
   };
   const validateQuery = async (query, schema, { auth } = {}) => {
@@ -2057,9 +2517,14 @@ const createContentAPIValidators = () => {
       await Promise.all(filters2.map((filter) => validateFilters(filter, schema, { auth })));
       return;
     }
-    const transforms = [defaultValidateFilters(schema)];
+    const transforms = [defaultValidateFilters({ schema, getModel })];
     if (auth) {
-      transforms.push(traverseQueryFilters(throwRestrictedRelations(auth), { schema }));
+      transforms.push(
+        traverseQueryFilters(throwRestrictedRelations(auth), {
+          schema,
+          getModel
+        })
+      );
     }
     await pipe(...transforms)(filters2);
   };
@@ -2067,9 +2532,14 @@ const createContentAPIValidators = () => {
     if (!schema) {
       throw new Error("Missing schema in validateSort");
     }
-    const transforms = [defaultValidateSort(schema)];
+    const transforms = [defaultValidateSort({ schema, getModel })];
     if (auth) {
-      transforms.push(traverseQuerySort(throwRestrictedRelations(auth), { schema }));
+      transforms.push(
+        traverseQuerySort(throwRestrictedRelations(auth), {
+          schema,
+          getModel
+        })
+      );
     }
     await pipe(...transforms)(sort2);
   };
@@ -2077,16 +2547,21 @@ const createContentAPIValidators = () => {
     if (!schema) {
       throw new Error("Missing schema in validateFields");
     }
-    const transforms = [defaultValidateFields(schema)];
+    const transforms = [defaultValidateFields({ schema, getModel })];
     await pipe(...transforms)(fields2);
   };
   const validatePopulate = async (populate2, schema, { auth } = {}) => {
     if (!schema) {
       throw new Error("Missing schema in sanitizePopulate");
     }
-    const transforms = [defaultValidatePopulate(schema)];
+    const transforms = [defaultValidatePopulate({ schema, getModel })];
     if (auth) {
-      transforms.push(traverseQueryPopulate(throwRestrictedRelations(auth), { schema }));
+      transforms.push(
+        traverseQueryPopulate(throwRestrictedRelations(auth), {
+          schema,
+          getModel
+        })
+      );
     }
     await pipe(...transforms)(populate2);
   };
@@ -2099,436 +2574,12 @@ const createContentAPIValidators = () => {
     populate: validatePopulate
   };
 };
-const contentAPI = createContentAPIValidators();
-const index = {
-  contentAPI,
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createAPIValidators,
   validators,
-  visitors
-};
-const { ID_ATTRIBUTE, DOC_ID_ATTRIBUTE, PUBLISHED_AT_ATTRIBUTE } = constants$1;
-class InvalidOrderError extends Error {
-  constructor() {
-    super();
-    this.message = "Invalid order. order can only be one of asc|desc|ASC|DESC";
-  }
-}
-class InvalidSortError extends Error {
-  constructor() {
-    super();
-    this.message = "Invalid sort parameter. Expected a string, an array of strings, a sort object or an array of sort objects";
-  }
-}
-function validateOrder(order) {
-  if (!fp.isString(order) || !["asc", "desc"].includes(order.toLocaleLowerCase())) {
-    throw new InvalidOrderError();
-  }
-}
-const convertCountQueryParams = (countQuery) => {
-  return parseType({ type: "boolean", value: countQuery });
-};
-const convertOrderingQueryParams = (ordering) => {
-  return ordering;
-};
-const isPlainObject = (value) => ___default.default.isPlainObject(value);
-const isStringArray = (value) => fp.isArray(value) && value.every(fp.isString);
-const convertSortQueryParams = (sortQuery) => {
-  if (typeof sortQuery === "string") {
-    return convertStringSortQueryParam(sortQuery);
-  }
-  if (isStringArray(sortQuery)) {
-    return sortQuery.flatMap((sortValue) => convertStringSortQueryParam(sortValue));
-  }
-  if (Array.isArray(sortQuery)) {
-    return sortQuery.map((sortValue) => convertNestedSortQueryParam(sortValue));
-  }
-  if (isPlainObject(sortQuery)) {
-    return convertNestedSortQueryParam(sortQuery);
-  }
-  throw new InvalidSortError();
-};
-const convertStringSortQueryParam = (sortQuery) => {
-  return sortQuery.split(",").map((value) => convertSingleSortQueryParam(value));
-};
-const convertSingleSortQueryParam = (sortQuery) => {
-  if (!sortQuery) {
-    return {};
-  }
-  if (!fp.isString(sortQuery)) {
-    throw new Error("Invalid sort query");
-  }
-  const [field, order = "asc"] = sortQuery.split(":");
-  if (field.length === 0) {
-    throw new Error("Field cannot be empty");
-  }
-  validateOrder(order);
-  return ___default.default.set({}, field, order);
-};
-const convertNestedSortQueryParam = (sortQuery) => {
-  const transformedSort = {};
-  for (const field of Object.keys(sortQuery)) {
-    const order = sortQuery[field];
-    if (isPlainObject(order)) {
-      transformedSort[field] = convertNestedSortQueryParam(order);
-    } else if (typeof order === "string") {
-      validateOrder(order);
-      transformedSort[field] = order;
-    } else {
-      throw Error(`Invalid sort type expected object or string got ${typeof order}`);
-    }
-  }
-  return transformedSort;
-};
-const convertStartQueryParams = (startQuery) => {
-  const startAsANumber = ___default.default.toNumber(startQuery);
-  if (!___default.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) {
-    throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
-  }
-  if (limitAsANumber === -1) {
-    return void 0;
-  }
-  return limitAsANumber;
-};
-const convertPageQueryParams = (page) => {
-  const pageVal = fp.toNumber(page);
-  if (!fp.isInteger(pageVal) || pageVal <= 0) {
-    throw new PaginationError(
-      `Invalid 'page' parameter. Expected an integer > 0, received: ${page}`
-    );
-  }
-  return pageVal;
-};
-const convertPageSizeQueryParams = (pageSize, page) => {
-  const pageSizeVal = fp.toNumber(pageSize);
-  if (!fp.isInteger(pageSizeVal) || pageSizeVal <= 0) {
-    throw new PaginationError(
-      `Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`
-    );
-  }
-  return pageSizeVal;
-};
-const validatePaginationParams = (page, pageSize, start, limit) => {
-  const isPagePagination = !fp.isNil(page) || !fp.isNil(pageSize);
-  const isOffsetPagination = !fp.isNil(start) || !fp.isNil(limit);
-  if (isPagePagination && isOffsetPagination) {
-    throw new PaginationError(
-      "Invalid pagination attributes. You cannot use page and offset pagination in the same query"
-    );
-  }
-};
-class InvalidPopulateError extends Error {
-  constructor() {
-    super();
-    this.message = "Invalid populate parameter. Expected a string, an array of strings, a populate object";
-  }
-}
-const convertPopulateQueryParams = (populate2, schema, depth = 0) => {
-  if (depth === 0 && populate2 === "*") {
-    return true;
-  }
-  if (typeof populate2 === "string") {
-    return populate2.split(",").map((value) => ___default.default.trim(value));
-  }
-  if (Array.isArray(populate2)) {
-    return ___default.default.uniq(
-      populate2.flatMap((value) => {
-        if (typeof value !== "string") {
-          throw new InvalidPopulateError();
-        }
-        return value.split(",").map((value2) => ___default.default.trim(value2));
-      })
-    );
-  }
-  if (___default.default.isPlainObject(populate2)) {
-    return convertPopulateObject(populate2, schema);
-  }
-  throw new InvalidPopulateError();
-};
-const hasFragmentPopulateDefined = (populate2) => {
-  return typeof populate2 === "object" && "on" in populate2 && !fp.isNil(populate2.on);
-};
-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 };
-    }
-    const attribute = attributes[key];
-    if (!attribute) {
-      return acc;
-    }
-    const isAllowedAttributeForFragmentPopulate = isDynamicZoneAttribute(attribute) || isMorphToRelationalAttribute(attribute);
-    if (isAllowedAttributeForFragmentPopulate && hasFragmentPopulateDefined(subPopulate)) {
-      return {
-        ...acc,
-        [key]: {
-          on: Object.entries(subPopulate.on).reduce(
-            (acc2, [type, typeSubPopulate]) => ({
-              ...acc2,
-              [type]: convertNestedPopulate(typeSubPopulate, strapi.getModel(type))
-            }),
-            {}
-          )
-        }
-      };
-    }
-    if (isDynamicZoneAttribute(attribute)) {
-      const populates = attribute.components.map((uid) => strapi.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 (isMorphToRelationalAttribute(attribute)) {
-      return { ...acc, [key]: convertNestedPopulate(subPopulate, void 0) };
-    }
-    let targetSchemaUID;
-    if (attribute.type === "relation") {
-      targetSchemaUID = attribute.target;
-    } else if (attribute.type === "component") {
-      targetSchemaUID = attribute.component;
-    } else if (attribute.type === "media") {
-      targetSchemaUID = "plugin::upload.file";
-    } else {
-      return acc;
-    }
-    const targetSchema = strapi.getModel(targetSchemaUID);
-    if (!targetSchema) {
-      return acc;
-    }
-    const populateObject = convertNestedPopulate(subPopulate, targetSchema);
-    if (!populateObject) {
-      return acc;
-    }
-    return {
-      ...acc,
-      [key]: populateObject
-    };
-  }, {});
-};
-const convertNestedPopulate = (subPopulate, schema) => {
-  if (___default.default.isString(subPopulate)) {
-    return parseType({ type: "boolean", value: subPopulate, forceCast: true });
-  }
-  if (___default.default.isBoolean(subPopulate)) {
-    return subPopulate;
-  }
-  if (!isPlainObject(subPopulate)) {
-    throw new Error(`Invalid nested populate. Expected '*' or an object`);
-  }
-  const { sort: sort2, filters: filters2, fields: fields2, populate: populate2, count, ordering, page, pageSize, start, limit } = subPopulate;
-  const query = {};
-  if (sort2) {
-    query.orderBy = convertSortQueryParams(sort2);
-  }
-  if (filters2) {
-    query.where = convertFiltersQueryParams(filters2, schema);
-  }
-  if (fields2) {
-    query.select = convertFieldsQueryParams(fields2);
-  }
-  if (populate2) {
-    query.populate = convertPopulateQueryParams(populate2, schema);
-  }
-  if (count) {
-    query.count = convertCountQueryParams(count);
-  }
-  if (ordering) {
-    query.ordering = convertOrderingQueryParams(ordering);
-  }
-  validatePaginationParams(page, pageSize, start, limit);
-  if (!fp.isNil(page)) {
-    query.page = convertPageQueryParams(page);
-  }
-  if (!fp.isNil(pageSize)) {
-    query.pageSize = convertPageSizeQueryParams(pageSize, page);
-  }
-  if (!fp.isNil(start)) {
-    query.offset = convertStartQueryParams(start);
-  }
-  if (!fp.isNil(limit)) {
-    query.limit = convertLimitQueryParams(limit);
-  }
-  return query;
-};
-const convertFieldsQueryParams = (fields2, depth = 0) => {
-  if (depth === 0 && fields2 === "*") {
-    return void 0;
-  }
-  if (typeof fields2 === "string") {
-    const fieldsValues = fields2.split(",").map((value) => ___default.default.trim(value));
-    return ___default.default.uniq([ID_ATTRIBUTE, DOC_ID_ATTRIBUTE, ...fieldsValues]);
-  }
-  if (isStringArray(fields2)) {
-    const fieldsValues = fields2.flatMap((value) => convertFieldsQueryParams(value, depth + 1)).filter((v) => !fp.isNil(v));
-    return ___default.default.uniq([ID_ATTRIBUTE, DOC_ID_ATTRIBUTE, ...fieldsValues]);
-  }
-  throw new Error("Invalid fields parameter. Expected a string or an array of strings");
-};
-const isValidSchemaAttribute = (key, schema) => {
-  if ([DOC_ID_ATTRIBUTE, ID_ATTRIBUTE].includes(key)) {
-    return true;
-  }
-  if (!schema) {
-    return false;
-  }
-  return Object.keys(schema.attributes).includes(key);
-};
-const convertFiltersQueryParams = (filters2, schema) => {
-  if (!fp.isObject(filters2)) {
-    throw new Error("The filters parameter must be an object or an array");
-  }
-  const filtersCopy = fp.cloneDeep(filters2);
-  return convertAndSanitizeFilters(filtersCopy, schema);
-};
-const convertAndSanitizeFilters = (filters2, schema) => {
-  if (Array.isArray(filters2)) {
-    return filters2.map((filter) => convertAndSanitizeFilters(filter, schema)).filter((filter) => !isPlainObject(filter) || !fp.isEmpty(filter));
-  }
-  if (!isPlainObject(filters2)) {
-    return filters2;
-  }
-  const removeOperator = (operator) => delete filters2[operator];
-  for (const [key, value] of Object.entries(filters2)) {
-    const attribute = fp.get(key, schema?.attributes);
-    const validKey = isOperator(key) || isValidSchemaAttribute(key, schema);
-    if (!validKey) {
-      removeOperator(key);
-    } else if (attribute) {
-      if (attribute.type === "relation") {
-        filters2[key] = convertAndSanitizeFilters(value, strapi.getModel(attribute.target));
-      } else if (attribute.type === "component") {
-        filters2[key] = convertAndSanitizeFilters(value, strapi.getModel(attribute.component));
-      } else if (attribute.type === "media") {
-        filters2[key] = convertAndSanitizeFilters(value, strapi.getModel("plugin::upload.file"));
-      } else if (attribute.type === "dynamiczone") {
-        removeOperator(key);
-      } else if (attribute.type === "password") {
-        removeOperator(key);
-      } else {
-        filters2[key] = convertAndSanitizeFilters(value, schema);
-      }
-    } else if (["$null", "$notNull"].includes(key)) {
-      filters2[key] = parseType({ type: "boolean", value: filters2[key], forceCast: true });
-    } else if (fp.isObject(value)) {
-      filters2[key] = convertAndSanitizeFilters(value, schema);
-    }
-    if (isPlainObject(filters2[key]) && fp.isEmpty(filters2[key])) {
-      removeOperator(key);
-    }
-  }
-  return filters2;
-};
-const convertStatusParams = (status, query = {}) => {
-  query.filters = ({ meta }) => {
-    const contentType = strapi.contentTypes[meta.uid];
-    if (!contentType || !hasDraftAndPublish(contentType)) {
-      return {};
-    }
-    return { [PUBLISHED_AT_ATTRIBUTE]: { $null: status === "draft" } };
-  };
-};
-const transformParamsToQuery = (uid, params) => {
-  const schema = strapi.getModel(uid);
-  const query = {};
-  const { _q, sort: sort2, filters: filters2, fields: fields2, populate: populate2, page, pageSize, start, limit, status, ...rest } = params;
-  if (!fp.isNil(status)) {
-    convertStatusParams(status, query);
-  }
-  if (!fp.isNil(_q)) {
-    query._q = _q;
-  }
-  if (!fp.isNil(sort2)) {
-    query.orderBy = convertSortQueryParams(sort2);
-  }
-  if (!fp.isNil(filters2)) {
-    query.where = convertFiltersQueryParams(filters2, schema);
-  }
-  if (!fp.isNil(fields2)) {
-    query.select = convertFieldsQueryParams(fields2);
-  }
-  if (!fp.isNil(populate2)) {
-    query.populate = convertPopulateQueryParams(populate2, schema);
-  }
-  validatePaginationParams(page, pageSize, start, limit);
-  if (!fp.isNil(page)) {
-    query.page = convertPageQueryParams(page);
-  }
-  if (!fp.isNil(pageSize)) {
-    query.pageSize = convertPageSizeQueryParams(pageSize, page);
-  }
-  if (!fp.isNil(start)) {
-    query.offset = convertStartQueryParams(start);
-  }
-  if (!fp.isNil(limit)) {
-    query.limit = convertLimitQueryParams(limit);
-  }
-  return {
-    ...rest,
-    ...query
-  };
-};
-const convertQueryParams = {
-  convertSortQueryParams,
-  convertStartQueryParams,
-  convertLimitQueryParams,
-  convertPopulateQueryParams,
-  convertFiltersQueryParams,
-  convertFieldsQueryParams,
-  transformParamsToQuery
-};
-function importDefault(modName) {
-  const mod = require(modName);
-  return mod && mod.__esModule ? mod.default : mod;
-}
-const machineId = () => {
-  try {
-    const deviceId = nodeMachineId.machineIdSync();
-    return deviceId;
-  } catch (error) {
-    const deviceId = crypto.randomUUID();
-    return deviceId;
-  }
-};
-const handleYupError = (error, errorMessage) => {
-  throw new YupValidationError(error, errorMessage);
-};
-const defaultValidationParam = { strict: true, abortEarly: false };
-const validateYupSchema = (schema, options = {}) => async (body, errorMessage) => {
-  try {
-    const optionsWithDefaults = fp.defaults(defaultValidationParam, options);
-    const result = await schema.validate(body, optionsWithDefaults);
-    return result;
-  } catch (e) {
-    if (e instanceof yup__namespace.ValidationError) {
-      handleYupError(e, errorMessage);
-    }
-    throw e;
-  }
-};
-const validateYupSchemaSync = (schema, options = {}) => (body, errorMessage) => {
-  try {
-    const optionsWithDefaults = fp.defaults(defaultValidationParam, options);
-    return schema.validateSync(body, optionsWithDefaults);
-  } catch (e) {
-    if (e instanceof yup__namespace.ValidationError) {
-      handleYupError(e, errorMessage);
-    }
-    throw e;
-  }
-};
+  visitors: index$1
+}, Symbol.toStringTag, { value: "Module" }));
 const STRAPI_DEFAULTS = {
   offset: {
     start: 0,
@@ -2680,72 +2731,6 @@ const file = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty
   streamToBuffer,
   writableDiscardStream
 }, Symbol.toStringTag, { value: "Module" }));
-const PLUGIN_PREFIX = "plugin::";
-const API_PREFIX = "api::";
-const parsePolicy = (policy2) => {
-  if (typeof policy2 === "string") {
-    return { policyName: policy2, config: {} };
-  }
-  const { name, config } = policy2;
-  return { policyName: name, config };
-};
-const searchLocalPolicy = (policyName, policyContext) => {
-  const { pluginName, apiName } = policyContext ?? {};
-  if (pluginName) {
-    return strapi.policy(`${PLUGIN_PREFIX}${pluginName}.${policyName}`);
-  }
-  if (apiName) {
-    return strapi.policy(`${API_PREFIX}${apiName}.${policyName}`);
-  }
-};
-const globalPolicy = ({ method, endpoint, controller, action, plugin }) => {
-  return async (ctx, next) => {
-    ctx.request.route = {
-      endpoint: `${method} ${endpoint}`,
-      controller: ___default.default.toLower(controller),
-      action: ___default.default.toLower(action),
-      verb: ___default.default.toLower(method),
-      plugin
-    };
-    await next();
-  };
-};
-const resolvePolicies = (config, policyContext) => {
-  const { pluginName, apiName } = policyContext ?? {};
-  return config.map((policyConfig) => {
-    return {
-      handler: getPolicy(policyConfig, { pluginName, apiName }),
-      config: typeof policyConfig === "object" && policyConfig.config || {}
-    };
-  });
-};
-const findPolicy = (name, policyContext) => {
-  const { pluginName, apiName } = policyContext ?? {};
-  const resolvedPolicy = strapi.policy(name);
-  if (resolvedPolicy !== void 0) {
-    return resolvedPolicy;
-  }
-  const localPolicy = searchLocalPolicy(name, { pluginName, apiName });
-  if (localPolicy !== void 0) {
-    return localPolicy;
-  }
-  throw new Error(`Could not find policy "${name}"`);
-};
-const getPolicy = (policyConfig, policyContext) => {
-  const { pluginName, apiName } = policyContext ?? {};
-  if (typeof policyConfig === "function") {
-    return policyConfig;
-  }
-  const { policyName, config } = parsePolicy(policyConfig);
-  const policy2 = findPolicy(policyName, { pluginName, apiName });
-  if (typeof policy2 === "function") {
-    return policy2;
-  }
-  if (policy2.validator) {
-    policy2.validator(config);
-  }
-  return policy2.handler;
-};
 const createPolicy = (options) => {
   const { name = "unnamed", validator, handler } = options;
   const wrappedValidator = (config) => {
@@ -2777,10 +2762,7 @@ const createPolicyContext = (type, ctx) => {
 const policy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   createPolicy,
-  createPolicyContext,
-  get: getPolicy,
-  globalPolicy,
-  resolve: resolvePolicies
+  createPolicyContext
 }, Symbol.toStringTag, { value: "Module" }));
 const nameToSlug = (name, options = { separator: "-" }) => slugify__default.default(name, options);
 const nameToCollectionName = (name) => slugify__default.default(name, { separator: "_" });
@@ -3022,7 +3004,6 @@ const relations = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePro
 exports.arrays = arrays;
 exports.async = async;
 exports.contentTypes = contentTypes;
-exports.convertQueryParams = convertQueryParams;
 exports.dates = dates;
 exports.env = env;
 exports.errors = errors;
@@ -3038,12 +3019,13 @@ exports.pagination = pagination;
 exports.parseType = parseType;
 exports.policy = policy;
 exports.providerFactory = providerFactory;
+exports.queryParams = convertQueryParams;
 exports.relations = relations;
-exports.sanitize = index$1;
+exports.sanitize = index$2;
 exports.setCreatorFields = setCreatorFields;
 exports.strings = strings;
 exports.template = template;
-exports.traverse = index$2;
+exports.traverse = index$3;
 exports.traverseEntity = traverseEntity$1;
 exports.validate = index;
 exports.validateYupSchema = validateYupSchema;