@strapi/utils 4.20.5 → 5.0.0-alpha.0

package/dist/index.mjs

@@ -1,10 +1,14 @@
-import _$1, { isString, isPlainObject as isPlainObject$1, kebabCase } from "lodash";
-import { eq, isEmpty, toPath, defaults, trimChars, trimCharsEnd, trimCharsStart, get, isNumber, isInteger, has, union, getOr, assoc, assign, cloneDeep, remove, merge, isNil, pipe, omit, curry, isArray, isString as isString$1, isObject, clone, pick, trim, split, map, flatten, first, join, constant, mergeAll, toNumber } from "lodash/fp";
-import * as yup$1 from "yup";
-import { HttpError } from "http-errors";
-import slugify from "@sindresorhus/slugify";
+import _$1, { kebabCase } from "lodash";
+import { has, union, getOr, assoc, assign, cloneDeep, remove, eq, curry, isArray, isString, isNil, toPath, isObject, clone, pick, isEmpty, omit, trim, pipe as pipe$1, split, map as map$1, flatten, first, identity, constant, join, merge, mergeAll, get, toNumber, isInteger, defaults, trimChars, trimCharsEnd, trimCharsStart, isNumber } from "lodash/fp";
 import pMap from "p-map";
+import { HttpError } from "http-errors";
+import { randomUUID } from "crypto";
+import { machineIdSync } from "node-machine-id";
+import * as yup$1 from "yup";
+import execa from "execa";
+import preferredPM from "preferred-pm";
 import { Writable } from "node:stream";
+import slugify from "@sindresorhus/slugify";
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {
     const e = m[i];
@@ -24,53 +28,20 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const parseMultipartData = (ctx) => {
-  if (!ctx.is("multipart")) {
-    return { data: ctx.request.body, files: {} };
-  }
-  const { body = {}, files = {} } = ctx.request;
-  if (!body.data) {
-    return ctx.badRequest(
-      `When using multipart/form-data you need to provide your data in a JSON 'data' field.`
-    );
-  }
-  let data;
-  try {
-    data = JSON.parse(body.data);
-  } catch (error) {
-    return ctx.badRequest(`Invalid 'data' field. 'data' should be a valid JSON.`);
-  }
-  const filesToUpload = Object.keys(files).reduce((acc2, key2) => {
-    const fullPath = _$1.toPath(key2);
-    if (fullPath.length <= 1 || fullPath[0] !== "files") {
-      return ctx.badRequest(
-        `When using multipart/form-data you need to provide your files by prefixing them with the 'files'.
-For example, when a media file is named "avatar", make sure the form key name is "files.avatar"`
-      );
-    }
-    const path = _$1.tail(fullPath);
-    acc2[path.join(".")] = files[key2];
-    return acc2;
-  }, {});
-  return {
-    data,
-    files: filesToUpload
-  };
-};
 const _ = require("lodash");
-const dates = require("date-fns");
+const dates$1 = require("date-fns");
 const timeRegex = /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$/;
 const isDate = (v) => {
-  return dates.isDate(v);
+  return dates$1.isDate(v);
 };
-const parseTime = (value2) => {
-  if (isDate(value2)) {
-    return dates.format(value2, "HH:mm:ss.SSS");
+const parseTime = (value) => {
+  if (isDate(value)) {
+    return dates$1.format(value, "HH:mm:ss.SSS");
   }
-  if (typeof value2 !== "string") {
-    throw new Error(`Expected a string, got a ${typeof value2}`);
+  if (typeof value !== "string") {
+    throw new Error(`Expected a string, got a ${typeof value}`);
   }
-  const result = value2.match(timeRegex);
+  const result = value.match(timeRegex);
   if (result === null) {
     throw new Error("Invalid time format, expected HH:mm:ss.SSS");
   }
@@ -78,721 +49,289 @@ const parseTime = (value2) => {
   const fractionPart = _.padEnd(fraction.slice(1), 3, "0");
   return `${hours}:${minutes}:${seconds}.${fractionPart}`;
 };
-const parseDate = (value2) => {
-  if (isDate(value2)) {
-    return dates.format(value2, "yyyy-MM-dd");
+const parseDate = (value) => {
+  if (isDate(value)) {
+    return dates$1.format(value, "yyyy-MM-dd");
   }
-  if (typeof value2 !== "string") {
-    throw new Error(`Expected a string, got a ${typeof value2}`);
+  if (typeof value !== "string") {
+    throw new Error(`Expected a string, got a ${typeof value}`);
   }
   try {
-    const date = dates.parseISO(value2);
-    if (dates.isValid(date))
-      return dates.format(date, "yyyy-MM-dd");
+    const date = dates$1.parseISO(value);
+    if (dates$1.isValid(date))
+      return dates$1.format(date, "yyyy-MM-dd");
     throw new Error(`Invalid format, expected an ISO compatible date`);
   } catch (error) {
     throw new Error(`Invalid format, expected an ISO compatible date`);
   }
 };
-const parseDateTimeOrTimestamp = (value2) => {
-  if (isDate(value2)) {
-    return value2;
+const parseDateTimeOrTimestamp = (value) => {
+  if (isDate(value)) {
+    return value;
   }
-  if (typeof value2 !== "string") {
-    throw new Error(`Expected a string, got a ${typeof value2}`);
+  if (typeof value !== "string") {
+    throw new Error(`Expected a string, got a ${typeof value}`);
   }
   try {
-    const date = dates.parseISO(value2);
-    if (dates.isValid(date))
+    const date = dates$1.parseISO(value);
+    if (dates$1.isValid(date))
       return date;
-    const milliUnixDate = dates.parse(value2, "T", /* @__PURE__ */ new Date());
-    if (dates.isValid(milliUnixDate))
+    const milliUnixDate = dates$1.parse(value, "T", /* @__PURE__ */ new Date());
+    if (dates$1.isValid(milliUnixDate))
       return milliUnixDate;
     throw new Error(`Invalid format, expected a timestamp or an ISO date`);
   } catch (error) {
     throw new Error(`Invalid format, expected a timestamp or an ISO date`);
   }
 };
-const parseBoolean = (value2, options) => {
+const parseBoolean = (value, options) => {
   const { forceCast = false } = options;
-  if (typeof value2 === "boolean") {
-    return value2;
+  if (typeof value === "boolean") {
+    return value;
   }
-  if (typeof value2 === "string" || typeof value2 === "number") {
-    if (["true", "t", "1", 1].includes(value2)) {
+  if (typeof value === "string" || typeof value === "number") {
+    if (["true", "t", "1", 1].includes(value)) {
       return true;
     }
-    if (["false", "f", "0", 0].includes(value2)) {
+    if (["false", "f", "0", 0].includes(value)) {
       return false;
     }
   }
   if (forceCast) {
-    return Boolean(value2);
+    return Boolean(value);
   }
   throw new Error('Invalid boolean input. Expected "t","1","true","false","0","f"');
 };
 const parseType = (options) => {
-  const { type, value: value2, forceCast } = options;
+  const { type, value, forceCast } = options;
   switch (type) {
     case "boolean":
-      return parseBoolean(value2, { forceCast });
+      return parseBoolean(value, { forceCast });
     case "integer":
     case "biginteger":
     case "float":
     case "decimal": {
-      return _.toNumber(value2);
+      return _.toNumber(value);
     }
     case "time": {
-      return parseTime(value2);
+      return parseTime(value);
     }
     case "date": {
-      return parseDate(value2);
+      return parseDate(value);
     }
     case "timestamp":
     case "datetime": {
-      return parseDateTimeOrTimestamp(value2);
+      return parseDateTimeOrTimestamp(value);
     }
     default:
-      return value2;
-  }
-};
-const PLUGIN_PREFIX = "plugin::";
-const API_PREFIX = "api::";
-const parsePolicy = (policy2) => {
-  if (typeof policy2 === "string") {
-    return { policyName: policy2, config: {} };
+      return value;
   }
-  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}`);
+function envFn(key, defaultValue) {
+  return _$1.has(process.env, key) ? process.env[key] : defaultValue;
+}
+function getKey(key) {
+  return process.env[key] ?? "";
+}
+const utils = {
+  int(key, defaultValue) {
+    if (!_$1.has(process.env, key)) {
+      return defaultValue;
+    }
+    return parseInt(getKey(key), 10);
+  },
+  float(key, defaultValue) {
+    if (!_$1.has(process.env, key)) {
+      return defaultValue;
+    }
+    return parseFloat(getKey(key));
+  },
+  bool(key, defaultValue) {
+    if (!_$1.has(process.env, key)) {
+      return defaultValue;
+    }
+    return getKey(key) === "true";
+  },
+  json(key, defaultValue) {
+    if (!_$1.has(process.env, key)) {
+      return defaultValue;
+    }
+    try {
+      return JSON.parse(getKey(key));
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Invalid json environment variable ${key}: ${error.message}`);
+      }
+      throw error;
+    }
+  },
+  array(key, defaultValue) {
+    if (!_$1.has(process.env, key)) {
+      return defaultValue;
+    }
+    let value = getKey(key);
+    if (value.startsWith("[") && value.endsWith("]")) {
+      value = value.substring(1, value.length - 1);
+    }
+    return value.split(",").map((v) => {
+      return _$1.trim(_$1.trim(v, " "), '"');
+    });
+  },
+  date(key, defaultValue) {
+    if (!_$1.has(process.env, key)) {
+      return defaultValue;
+    }
+    return new Date(getKey(key));
+  },
+  /**
+   * Gets a value from env that matches oneOf provided values
+   * @param {string} key
+   * @param {string[]} expectedValues
+   * @param {string|undefined} defaultValue
+   * @returns {string|undefined}
+   */
+  oneOf(key, expectedValues, defaultValue) {
+    if (!expectedValues) {
+      throw new Error(`env.oneOf requires expectedValues`);
+    }
+    if (defaultValue && !expectedValues.includes(defaultValue)) {
+      throw new Error(`env.oneOf requires defaultValue to be included in expectedValues`);
+    }
+    const rawValue = env(key, defaultValue);
+    return expectedValues.includes(rawValue) ? rawValue : defaultValue;
   }
 };
-const globalPolicy = ({ method, endpoint, controller, action, plugin }) => {
-  return async (ctx, next) => {
-    ctx.request.route = {
-      endpoint: `${method} ${endpoint}`,
-      controller: _$1.toLower(controller),
-      action: _$1.toLower(action),
-      verb: _$1.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 env = Object.assign(envFn, utils);
+const SINGLE_TYPE = "singleType";
+const COLLECTION_TYPE = "collectionType";
+const ID_ATTRIBUTE$4 = "id";
+const DOC_ID_ATTRIBUTE$4 = "documentId";
+const PUBLISHED_AT_ATTRIBUTE$1 = "publishedAt";
+const CREATED_BY_ATTRIBUTE$3 = "createdBy";
+const UPDATED_BY_ATTRIBUTE$3 = "updatedBy";
+const CREATED_AT_ATTRIBUTE = "createdAt";
+const UPDATED_AT_ATTRIBUTE = "updatedAt";
+const constants$1 = {
+  ID_ATTRIBUTE: ID_ATTRIBUTE$4,
+  DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$4,
+  PUBLISHED_AT_ATTRIBUTE: PUBLISHED_AT_ATTRIBUTE$1,
+  CREATED_BY_ATTRIBUTE: CREATED_BY_ATTRIBUTE$3,
+  UPDATED_BY_ATTRIBUTE: UPDATED_BY_ATTRIBUTE$3,
+  CREATED_AT_ATTRIBUTE,
+  UPDATED_AT_ATTRIBUTE,
+  SINGLE_TYPE,
+  COLLECTION_TYPE
 };
-const findPolicy = (name, policyContext) => {
-  const { pluginName, apiName } = policyContext ?? {};
-  const resolvedPolicy = strapi.policy(name);
-  if (resolvedPolicy !== void 0) {
-    return resolvedPolicy;
+const getTimestamps = (model) => {
+  const attributes = [];
+  if (has(CREATED_AT_ATTRIBUTE, model.attributes)) {
+    attributes.push(CREATED_AT_ATTRIBUTE);
   }
-  const localPolicy = searchLocalPolicy(name, { pluginName, apiName });
-  if (localPolicy !== void 0) {
-    return localPolicy;
+  if (has(UPDATED_AT_ATTRIBUTE, model.attributes)) {
+    attributes.push(UPDATED_AT_ATTRIBUTE);
   }
-  throw new Error(`Could not find policy "${name}"`);
+  return attributes;
 };
-const getPolicy = (policyConfig, policyContext) => {
-  const { pluginName, apiName } = policyContext ?? {};
-  if (typeof policyConfig === "function") {
-    return policyConfig;
+const getCreatorFields = (model) => {
+  const attributes = [];
+  if (has(CREATED_BY_ATTRIBUTE$3, model.attributes)) {
+    attributes.push(CREATED_BY_ATTRIBUTE$3);
   }
-  const { policyName, config } = parsePolicy(policyConfig);
-  const policy2 = findPolicy(policyName, { pluginName, apiName });
-  if (typeof policy2 === "function") {
-    return policy2;
+  if (has(UPDATED_BY_ATTRIBUTE$3, model.attributes)) {
+    attributes.push(UPDATED_BY_ATTRIBUTE$3);
   }
-  if (policy2.validator) {
-    policy2.validator(config);
+  return attributes;
+};
+const getNonWritableAttributes = (model) => {
+  if (!model)
+    return [];
+  const nonWritableAttributes = _$1.reduce(
+    model.attributes,
+    (acc, attr, attrName) => attr.writable === false ? acc.concat(attrName) : acc,
+    []
+  );
+  return _$1.uniq([
+    ID_ATTRIBUTE$4,
+    DOC_ID_ATTRIBUTE$4,
+    ...getTimestamps(model),
+    ...nonWritableAttributes
+  ]);
+};
+const getWritableAttributes = (model) => {
+  if (!model)
+    return [];
+  return _$1.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
+};
+const isWritableAttribute = (model, attributeName) => {
+  return getWritableAttributes(model).includes(attributeName);
+};
+const getNonVisibleAttributes = (model) => {
+  const nonVisibleAttributes = _$1.reduce(
+    model.attributes,
+    (acc, attr, attrName) => attr.visible === false ? acc.concat(attrName) : acc,
+    []
+  );
+  return _$1.uniq([ID_ATTRIBUTE$4, DOC_ID_ATTRIBUTE$4, ...getTimestamps(model), ...nonVisibleAttributes]);
+};
+const getVisibleAttributes = (model) => {
+  return _$1.difference(_$1.keys(model.attributes), getNonVisibleAttributes(model));
+};
+const isVisibleAttribute = (model, attributeName) => {
+  return getVisibleAttributes(model).includes(attributeName);
+};
+const getOptions = (model) => _$1.assign({ draftAndPublish: false }, _$1.get(model, "options", {}));
+const hasDraftAndPublish = (model) => _$1.get(model, "options.draftAndPublish", false) === true;
+const isDraft = (data, model) => hasDraftAndPublish(model) && _$1.get(data, PUBLISHED_AT_ATTRIBUTE$1) === null;
+const isSingleType = ({ kind = COLLECTION_TYPE }) => kind === SINGLE_TYPE;
+const isCollectionType = ({ kind = COLLECTION_TYPE }) => kind === COLLECTION_TYPE;
+const isKind = (kind) => (model) => model.kind === kind;
+const getStoredPrivateAttributes = (model) => union(
+  strapi?.config?.get("api.responses.privateAttributes", []) ?? [],
+  getOr([], "options.privateAttributes", model)
+);
+const getPrivateAttributes = (model) => {
+  return _$1.union(
+    getStoredPrivateAttributes(model),
+    _$1.keys(_$1.pickBy(model.attributes, (attr) => !!attr.private))
+  );
+};
+const isPrivateAttribute = (model, attributeName) => {
+  if (model?.attributes?.[attributeName]?.private === true) {
+    return true;
   }
-  return policy2.handler;
+  return getStoredPrivateAttributes(model).includes(attributeName);
 };
-const createPolicy = (options) => {
-  const { name = "unnamed", validator, handler } = options;
-  const wrappedValidator = (config) => {
-    if (validator) {
-      try {
-        validator(config);
-      } catch (e) {
-        throw new Error(`Invalid config passed to "${name}" policy.`);
-      }
-    }
-  };
-  return {
-    name,
-    validator: wrappedValidator,
-    handler
-  };
+const isScalarAttribute = (attribute) => {
+  return !["media", "component", "relation", "dynamiczone"].includes(attribute?.type);
 };
-const createPolicyContext = (type, ctx) => {
-  return Object.assign(
-    {
-      is: eq(type),
-      get type() {
-        return type;
-      }
+const isMediaAttribute = (attribute) => attribute?.type === "media";
+const isRelationalAttribute = (attribute) => attribute?.type === "relation";
+const isComponentAttribute = (attribute) => ["component", "dynamiczone"].includes(attribute?.type);
+const isDynamicZoneAttribute = (attribute) => attribute?.type === "dynamiczone";
+const isMorphToRelationalAttribute = (attribute) => {
+  return isRelationalAttribute(attribute) && attribute?.relation?.startsWith?.("morphTo");
+};
+const getComponentAttributes = (schema) => {
+  return _$1.reduce(
+    schema.attributes,
+    (acc, attr, attrName) => {
+      if (isComponentAttribute(attr))
+        acc.push(attrName);
+      return acc;
     },
-    ctx
+    []
   );
 };
-const policy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  createPolicy,
-  createPolicyContext,
-  get: getPolicy,
-  globalPolicy,
-  resolve: resolvePolicies
-}, Symbol.toStringTag, { value: "Module" }));
-const regex = /\$\{[^()]*\}/g;
-const excludeConfigPaths = ["info.scripts"];
-const isObj$3 = (value2) => isPlainObject$1(value2);
-const templateConfiguration = (obj, configPath = "") => {
-  return Object.keys(obj).reduce((acc, key) => {
-    const value = obj[key];
-    if (isObj$3(value) && !isString(value)) {
-      acc[key] = templateConfiguration(value, `${configPath}.${key}`);
-    } else if (isString(value) && !excludeConfigPaths.includes(configPath.substr(1)) && value.match(regex) !== null) {
-      acc[key] = eval("`" + value + "`");
-    } else {
-      acc[key] = value;
-    }
-    return acc;
-  }, {});
-};
-const formatYupInnerError = (yupError) => ({
-  path: toPath(yupError.path),
-  message: yupError.message,
-  name: yupError.name
-});
-const formatYupErrors = (yupError) => ({
-  errors: 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,
-  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 = defaults(defaultValidationParam, options);
-    const result = await schema.validate(body, optionsWithDefaults);
-    return result;
-  } catch (e) {
-    if (e instanceof yup$1.ValidationError) {
-      handleYupError(e, errorMessage);
-    }
-    throw e;
-  }
-};
-const validateYupSchemaSync = (schema, options = {}) => (body, errorMessage) => {
-  try {
-    const optionsWithDefaults = defaults(defaultValidationParam, options);
-    return schema.validateSync(body, optionsWithDefaults);
-  } catch (e) {
-    if (e instanceof yup$1.ValidationError) {
-      handleYupError(e, errorMessage);
-    }
-    throw e;
-  }
-};
-const nameToSlug = (name, options = { separator: "-" }) => slugify(name, options);
-const nameToCollectionName = (name) => slugify(name, { separator: "_" });
-const toRegressedEnumValue = (value2) => slugify(value2, {
-  decamelize: false,
-  lowercase: false,
-  separator: "_"
-});
-const getCommonBeginning = (...strings) => _$1.takeWhile(strings[0], (char, index2) => strings.every((string) => string[index2] === char)).join(
-  ""
-);
-const getCommonPath = (...paths) => {
-  const [segments, ...otherSegments] = paths.map((it) => _$1.split(it, "/"));
-  return _$1.join(
-    _$1.takeWhile(segments, (str, index2) => otherSegments.every((it) => it[index2] === str)),
-    "/"
-  );
-};
-const escapeQuery = (query, charsToEscape, escapeChar = "\\") => {
-  return query.split("").reduce(
-    (escapedQuery, char) => charsToEscape.includes(char) ? `${escapedQuery}${escapeChar}${char}` : `${escapedQuery}${char}`,
-    ""
-  );
-};
-const stringIncludes = (arr, val) => arr.map(String).includes(String(val));
-const stringEquals = (a, b) => String(a) === String(b);
-const isCamelCase = (value2) => /^[a-z][a-zA-Z0-9]+$/.test(value2);
-const isKebabCase = (value2) => /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/.test(value2);
-const startsWithANumber = (value2) => /^[0-9]/.test(value2);
-const joinBy = (joint, ...args) => {
-  const trim2 = trimChars(joint);
-  const trimEnd = trimCharsEnd(joint);
-  const trimStart = trimCharsStart(joint);
-  return args.reduce((url, path, index2) => {
-    if (args.length === 1)
-      return path;
-    if (index2 === 0)
-      return trimEnd(path);
-    if (index2 === args.length - 1)
-      return url + joint + trimStart(path);
-    return url + joint + trim2(path);
-  }, "");
-};
-const toKebabCase = (value2) => kebabCase(value2);
-const { toString } = Object.prototype;
-const errorToString = Error.prototype.toString;
-const regExpToString = RegExp.prototype.toString;
-const symbolToString = typeof Symbol !== "undefined" ? Symbol.prototype.toString : () => "";
-const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
-function printNumber(val) {
-  if (val != +val)
-    return "NaN";
-  const isNegativeZero = val === 0 && 1 / val < 0;
-  return isNegativeZero ? "-0" : `${val}`;
-}
-function printSimpleValue(val, quoteStrings = false) {
-  if (val == null || val === true || val === false)
-    return `${val}`;
-  if (typeof val === "number")
-    return printNumber(val);
-  if (typeof val === "string")
-    return quoteStrings ? `"${val}"` : val;
-  if (typeof val === "function")
-    return `[Function ${val.name || "anonymous"}]`;
-  if (typeof val === "symbol")
-    return symbolToString.call(val).replace(SYMBOL_REGEXP, "Symbol($1)");
-  const tag = toString.call(val).slice(8, -1);
-  if (tag === "Date") {
-    const v = val;
-    return Number.isNaN(v.getTime()) ? `${v}` : v.toISOString();
-  }
-  if (tag === "Error" || val instanceof Error)
-    return `[${errorToString.call(val)}]`;
-  if (tag === "RegExp")
-    return regExpToString.call(val);
-  return null;
-}
-function printValue(value2, quoteStrings) {
-  const result = printSimpleValue(value2, quoteStrings);
-  if (result !== null)
-    return result;
-  return JSON.stringify(
-    value2,
-    function replacer(key2, value22) {
-      const result2 = printSimpleValue(this[key2], quoteStrings);
-      if (result2 !== null)
-        return result2;
-      return value22;
-    },
-    2
-  );
-}
-const strapiID = () => new StrapiIDSchema();
-const isNotNilTest = (value2) => !_$1.isNil(value2);
-const isNotNullTest = (value2) => !_$1.isNull(value2);
-yup$1.addMethod(yup$1.mixed, "notNil", function isNotNill(msg = "${path} must be defined.") {
-  return this.test("defined", msg, isNotNilTest);
-});
-yup$1.addMethod(yup$1.mixed, "notNull", function isNotNull(msg = "${path} cannot be null.") {
-  return this.test("defined", msg, isNotNullTest);
-});
-yup$1.addMethod(yup$1.mixed, "isFunction", function isFunction(message = "${path} is not a function") {
-  return this.test(
-    "is a function",
-    message,
-    (value2) => _$1.isUndefined(value2) || _$1.isFunction(value2)
-  );
-});
-yup$1.addMethod(
-  yup$1.string,
-  "isCamelCase",
-  function isCamelCase$1(message = "${path} is not in camel case (anExampleOfCamelCase)") {
-    return this.test(
-      "is in camelCase",
-      message,
-      (value2) => value2 ? isCamelCase(value2) : true
-    );
-  }
-);
-yup$1.addMethod(
-  yup$1.string,
-  "isKebabCase",
-  function isKebabCase$1(message = "${path} is not in kebab case (an-example-of-kebab-case)") {
-    return this.test(
-      "is in kebab-case",
-      message,
-      (value2) => value2 ? isKebabCase(value2) : true
-    );
-  }
-);
-yup$1.addMethod(
-  yup$1.object,
-  "onlyContainsFunctions",
-  function onlyContainsFunctions(message = "${path} contains values that are not functions") {
-    return this.test(
-      "only contains functions",
-      message,
-      (value2) => _$1.isUndefined(value2) || value2 && Object.values(value2).every(_$1.isFunction)
-    );
-  }
-);
-yup$1.addMethod(
-  yup$1.array,
-  "uniqueProperty",
-  function uniqueProperty(propertyName, message) {
-    return this.test("unique", message, function unique(list) {
-      const errors2 = [];
-      list?.forEach((element, index2) => {
-        const sameElements = list.filter(
-          (e) => get(propertyName, e) === get(propertyName, element)
-        );
-        if (sameElements.length > 1) {
-          errors2.push(
-            this.createError({
-              path: `${this.path}[${index2}].${propertyName}`,
-              message
-            })
-          );
-        }
-      });
-      if (errors2.length) {
-        throw new yup$1.ValidationError(errors2);
-      }
-      return true;
-    });
-  }
-);
-class StrapiIDSchema extends yup$1.MixedSchema {
-  constructor() {
-    super({ type: "strapiID" });
-  }
-  _typeCheck(value2) {
-    return typeof value2 === "string" || isNumber(value2) && isInteger(value2) && value2 >= 0;
-  }
-}
-yup$1.setLocale({
-  mixed: {
-    notType(options) {
-      const { path, type, value: value2, originalValue } = options;
-      const isCast = originalValue != null && originalValue !== value2;
-      const msg = `${path} must be a \`${type}\` type, but the final value was: \`${printValue(value2, true)}\`${isCast ? ` (cast from the value \`${printValue(originalValue, true)}\`).` : "."}`;
-      return msg;
-    }
-  }
-});
-const yup = /* @__PURE__ */ _mergeNamespaces({
-  __proto__: null,
-  StrapiIDSchema,
-  strapiID
-}, [yup$1]);
-const removeUndefined = (obj2) => _$1.pickBy(obj2, (value2) => typeof value2 !== "undefined");
-const keysDeep = (obj2, path = []) => !_$1.isObject(obj2) ? [path.join(".")] : _$1.reduce(
-  obj2,
-  (acc2, next, key2) => _$1.concat(acc2, keysDeep(next, [...path, key2])),
-  []
-);
-const getConfigUrls = (config, forAdminBuild = false) => {
-  const serverConfig = config.get("server");
-  const adminConfig = config.get("admin");
-  let serverUrl = _$1.get(serverConfig, "url", "");
-  serverUrl = _$1.trim(serverUrl, "/ ");
-  if (typeof serverUrl !== "string") {
-    throw new Error("Invalid server url config. Make sure the url is a string.");
-  }
-  if (serverUrl.startsWith("http")) {
-    try {
-      serverUrl = _$1.trim(new URL(serverConfig.url).toString(), "/");
-    } catch (e) {
-      throw new Error(
-        "Invalid server url config. Make sure the url defined in server.js is valid."
-      );
-    }
-  } else if (serverUrl !== "") {
-    serverUrl = `/${serverUrl}`;
-  }
-  let adminUrl = _$1.get(adminConfig, "url", "/admin");
-  adminUrl = _$1.trim(adminUrl, "/ ");
-  if (typeof adminUrl !== "string") {
-    throw new Error("Invalid admin url config. Make sure the url is a non-empty string.");
-  }
-  if (adminUrl.startsWith("http")) {
-    try {
-      adminUrl = _$1.trim(new URL(adminUrl).toString(), "/");
-    } catch (e) {
-      throw new Error("Invalid admin url config. Make sure the url defined in server.js is valid.");
-    }
-  } else {
-    adminUrl = `${serverUrl}/${adminUrl}`;
-  }
-  let adminPath = adminUrl;
-  if (serverUrl.startsWith("http") && adminUrl.startsWith("http") && new URL(adminUrl).origin === new URL(serverUrl).origin && !forAdminBuild) {
-    adminPath = adminUrl.replace(getCommonPath(serverUrl, adminUrl), "");
-    adminPath = `/${_$1.trim(adminPath, "/")}`;
-  } else if (adminUrl.startsWith("http")) {
-    adminPath = new URL(adminUrl).pathname;
-  }
-  return {
-    serverUrl,
-    adminUrl,
-    adminPath
-  };
-};
-const getAbsoluteUrl = (adminOrServer) => (config, forAdminBuild = false) => {
-  const { serverUrl, adminUrl } = getConfigUrls(config, forAdminBuild);
-  const url = adminOrServer === "server" ? serverUrl : adminUrl;
-  if (url.startsWith("http")) {
-    return url;
-  }
-  const hostname = config.get("environment") === "development" && ["127.0.0.1", "0.0.0.0"].includes(config.get("server.host")) ? "localhost" : config.get("server.host");
-  return `http://${hostname}:${config.get("server.port")}${url}`;
-};
-const getAbsoluteAdminUrl = getAbsoluteUrl("admin");
-const getAbsoluteServerUrl = getAbsoluteUrl("server");
-const generateTimestampCode = (date) => {
-  const referDate = date || /* @__PURE__ */ new Date();
-  return referDate.getTime().toString(36);
-};
-const SINGLE_TYPE = "singleType";
-const COLLECTION_TYPE = "collectionType";
-const ID_ATTRIBUTE = "id";
-const PUBLISHED_AT_ATTRIBUTE$1 = "publishedAt";
-const CREATED_BY_ATTRIBUTE$3 = "createdBy";
-const UPDATED_BY_ATTRIBUTE$3 = "updatedBy";
-const CREATED_AT_ATTRIBUTE = "createdAt";
-const UPDATED_AT_ATTRIBUTE = "updatedAt";
-const DP_PUB_STATE_LIVE = "live";
-const DP_PUB_STATE_PREVIEW = "preview";
-const DP_PUB_STATES = [DP_PUB_STATE_LIVE, DP_PUB_STATE_PREVIEW];
-const constants$1 = {
-  ID_ATTRIBUTE,
-  PUBLISHED_AT_ATTRIBUTE: PUBLISHED_AT_ATTRIBUTE$1,
-  CREATED_BY_ATTRIBUTE: CREATED_BY_ATTRIBUTE$3,
-  UPDATED_BY_ATTRIBUTE: UPDATED_BY_ATTRIBUTE$3,
-  CREATED_AT_ATTRIBUTE,
-  UPDATED_AT_ATTRIBUTE,
-  DP_PUB_STATES,
-  DP_PUB_STATE_LIVE,
-  DP_PUB_STATE_PREVIEW,
-  SINGLE_TYPE,
-  COLLECTION_TYPE
-};
-const getTimestamps = (model) => {
-  const attributes = [];
-  if (has(CREATED_AT_ATTRIBUTE, model.attributes)) {
-    attributes.push(CREATED_AT_ATTRIBUTE);
-  }
-  if (has(UPDATED_AT_ATTRIBUTE, model.attributes)) {
-    attributes.push(UPDATED_AT_ATTRIBUTE);
-  }
-  return attributes;
-};
-const getCreatorFields = (model) => {
-  const attributes = [];
-  if (has(CREATED_BY_ATTRIBUTE$3, model.attributes)) {
-    attributes.push(CREATED_BY_ATTRIBUTE$3);
-  }
-  if (has(UPDATED_BY_ATTRIBUTE$3, model.attributes)) {
-    attributes.push(UPDATED_BY_ATTRIBUTE$3);
-  }
-  return attributes;
-};
-const getNonWritableAttributes = (model) => {
-  if (!model)
-    return [];
-  const nonWritableAttributes = _$1.reduce(
-    model.attributes,
-    (acc2, attr, attrName) => attr.writable === false ? acc2.concat(attrName) : acc2,
-    []
-  );
-  return _$1.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonWritableAttributes]);
-};
-const getWritableAttributes = (model) => {
-  if (!model)
-    return [];
-  return _$1.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
-};
-const isWritableAttribute = (model, attributeName) => {
-  return getWritableAttributes(model).includes(attributeName);
-};
-const getNonVisibleAttributes = (model) => {
-  const nonVisibleAttributes = _$1.reduce(
-    model.attributes,
-    (acc2, attr, attrName) => attr.visible === false ? acc2.concat(attrName) : acc2,
-    []
-  );
-  return _$1.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonVisibleAttributes]);
-};
-const getVisibleAttributes = (model) => {
-  return _$1.difference(_$1.keys(model.attributes), getNonVisibleAttributes(model));
-};
-const isVisibleAttribute = (model, attributeName) => {
-  return getVisibleAttributes(model).includes(attributeName);
-};
-const getOptions = (model) => _$1.assign({ draftAndPublish: false }, _$1.get(model, "options", {}));
-const hasDraftAndPublish = (model) => _$1.get(model, "options.draftAndPublish", false) === true;
-const isDraft = (data, model) => hasDraftAndPublish(model) && _$1.get(data, PUBLISHED_AT_ATTRIBUTE$1) === null;
-const isSingleType = ({ kind = COLLECTION_TYPE }) => kind === SINGLE_TYPE;
-const isCollectionType = ({ kind = COLLECTION_TYPE }) => kind === COLLECTION_TYPE;
-const isKind = (kind) => (model) => model.kind === kind;
-const getStoredPrivateAttributes = (model) => union(
-  strapi?.config?.get("api.responses.privateAttributes", []) ?? [],
-  getOr([], "options.privateAttributes", model)
-);
-const getPrivateAttributes = (model) => {
-  return _$1.union(
-    getStoredPrivateAttributes(model),
-    _$1.keys(_$1.pickBy(model.attributes, (attr) => !!attr.private))
-  );
-};
-const isPrivateAttribute = (model, attributeName) => {
-  if (model?.attributes?.[attributeName]?.private === true) {
-    return true;
-  }
-  return getStoredPrivateAttributes(model).includes(attributeName);
-};
-const isScalarAttribute = (attribute) => {
-  return !["media", "component", "relation", "dynamiczone"].includes(attribute?.type);
-};
-const isMediaAttribute = (attribute) => attribute?.type === "media";
-const isRelationalAttribute = (attribute) => attribute?.type === "relation";
-const isComponentAttribute = (attribute) => ["component", "dynamiczone"].includes(attribute?.type);
-const isDynamicZoneAttribute = (attribute) => attribute?.type === "dynamiczone";
-const isMorphToRelationalAttribute = (attribute) => {
-  return isRelationalAttribute(attribute) && attribute?.relation?.startsWith?.("morphTo");
-};
-const getComponentAttributes = (schema) => {
-  return _$1.reduce(
-    schema.attributes,
-    (acc2, attr, attrName) => {
-      if (isComponentAttribute(attr))
-        acc2.push(attrName);
-      return acc2;
-    },
-    []
-  );
-};
-const getScalarAttributes = (schema) => {
-  return _$1.reduce(
-    schema.attributes,
-    (acc2, attr, attrName) => {
-      if (isScalarAttribute(attr))
-        acc2.push(attrName);
-      return acc2;
-    },
-    []
-  );
+const getScalarAttributes = (schema) => {
+  return _$1.reduce(
+    schema.attributes,
+    (acc, attr, attrName) => {
+      if (isScalarAttribute(attr))
+        acc.push(attrName);
+      return acc;
+    },
+    []
+  );
 };
 const isTypedAttribute = (attribute, type) => {
   return _$1.has(attribute, "type") && attribute.type === type;
@@ -830,103 +369,6 @@ const contentTypes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.define
   isVisibleAttribute,
   isWritableAttribute
 }, Symbol.toStringTag, { value: "Module" }));
-function envFn(key2, defaultValue) {
-  return _$1.has(process.env, key2) ? process.env[key2] : defaultValue;
-}
-function getKey(key2) {
-  return process.env[key2] ?? "";
-}
-const utils = {
-  int(key2, defaultValue) {
-    if (!_$1.has(process.env, key2)) {
-      return defaultValue;
-    }
-    return parseInt(getKey(key2), 10);
-  },
-  float(key2, defaultValue) {
-    if (!_$1.has(process.env, key2)) {
-      return defaultValue;
-    }
-    return parseFloat(getKey(key2));
-  },
-  bool(key2, defaultValue) {
-    if (!_$1.has(process.env, key2)) {
-      return defaultValue;
-    }
-    return getKey(key2) === "true";
-  },
-  json(key2, defaultValue) {
-    if (!_$1.has(process.env, key2)) {
-      return defaultValue;
-    }
-    try {
-      return JSON.parse(getKey(key2));
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Invalid json environment variable ${key2}: ${error.message}`);
-      }
-      throw error;
-    }
-  },
-  array(key2, defaultValue) {
-    if (!_$1.has(process.env, key2)) {
-      return defaultValue;
-    }
-    let value2 = getKey(key2);
-    if (value2.startsWith("[") && value2.endsWith("]")) {
-      value2 = value2.substring(1, value2.length - 1);
-    }
-    return value2.split(",").map((v) => {
-      return _$1.trim(_$1.trim(v, " "), '"');
-    });
-  },
-  date(key2, defaultValue) {
-    if (!_$1.has(process.env, key2)) {
-      return defaultValue;
-    }
-    return new Date(getKey(key2));
-  },
-  /**
-   * Gets a value from env that matches oneOf provided values
-   * @param {string} key
-   * @param {string[]} expectedValues
-   * @param {string|undefined} defaultValue
-   * @returns {string|undefined}
-   */
-  oneOf(key2, expectedValues, defaultValue) {
-    if (!expectedValues) {
-      throw new Error(`env.oneOf requires expectedValues`);
-    }
-    if (defaultValue && !expectedValues.includes(defaultValue)) {
-      throw new Error(`env.oneOf requires defaultValue to be included in expectedValues`);
-    }
-    const rawValue = env(key2, defaultValue);
-    return expectedValues.includes(rawValue) ? rawValue : defaultValue;
-  }
-};
-const env = Object.assign(envFn, utils);
-const MANY_RELATIONS = ["oneToMany", "manyToMany"];
-const getRelationalFields = (contentType) => {
-  return Object.keys(contentType.attributes).filter((attributeName) => {
-    return contentType.attributes[attributeName].type === "relation";
-  });
-};
-const isOneToAny = (attribute) => isRelationalAttribute(attribute) && ["oneToOne", "oneToMany"].includes(attribute.relation);
-const isManyToAny = (attribute) => isRelationalAttribute(attribute) && ["manyToMany", "manyToOne"].includes(attribute.relation);
-const isAnyToOne = (attribute) => isRelationalAttribute(attribute) && ["oneToOne", "manyToOne"].includes(attribute.relation);
-const isAnyToMany = (attribute) => isRelationalAttribute(attribute) && ["oneToMany", "manyToMany"].includes(attribute.relation);
-const constants = {
-  MANY_RELATIONS
-};
-const relations = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  constants,
-  getRelationalFields,
-  isAnyToMany,
-  isAnyToOne,
-  isManyToAny,
-  isOneToAny
-}, Symbol.toStringTag, { value: "Module" }));
 const { CREATED_BY_ATTRIBUTE: CREATED_BY_ATTRIBUTE$2, UPDATED_BY_ATTRIBUTE: UPDATED_BY_ATTRIBUTE$2 } = constants$1;
 const setCreatorFields = ({ user, isEdition = false }) => (data) => {
   if (isEdition) {
@@ -1022,26 +464,26 @@ const providerFactory = (options = {}) => {
   };
   return {
     hooks: state.hooks,
-    async register(key2, item) {
-      if (throwOnDuplicates && this.has(key2)) {
-        throw new Error(`Duplicated item key: ${key2}`);
+    async register(key, item) {
+      if (throwOnDuplicates && this.has(key)) {
+        throw new Error(`Duplicated item key: ${key}`);
       }
-      await state.hooks.willRegister.call({ key: key2, value: item });
-      state.registry.set(key2, item);
-      await state.hooks.didRegister.call({ key: key2, value: cloneDeep(item) });
+      await state.hooks.willRegister.call({ key, value: item });
+      state.registry.set(key, item);
+      await state.hooks.didRegister.call({ key, value: cloneDeep(item) });
       return this;
     },
-    async delete(key2) {
-      if (this.has(key2)) {
-        const item = this.get(key2);
-        await state.hooks.willDelete.call({ key: key2, value: cloneDeep(item) });
-        state.registry.delete(key2);
-        await state.hooks.didDelete.call({ key: key2, value: cloneDeep(item) });
+    async delete(key) {
+      if (this.has(key)) {
+        const item = this.get(key);
+        await state.hooks.willDelete.call({ key, value: cloneDeep(item) });
+        state.registry.delete(key);
+        await state.hooks.didDelete.call({ key, value: cloneDeep(item) });
       }
       return this;
     },
-    get(key2) {
-      return state.registry.get(key2);
+    get(key) {
+      return state.registry.get(key);
     },
     getWhere(filters2 = {}) {
       const items = this.values();
@@ -1050,7 +492,7 @@ const providerFactory = (options = {}) => {
         return items;
       }
       return items.filter((item) => {
-        return filtersEntries.every(([key2, value2]) => item[key2] === value2);
+        return filtersEntries.every(([key, value]) => item[key] === value);
       });
     },
     values() {
@@ -1059,93 +501,22 @@ const providerFactory = (options = {}) => {
     keys() {
       return Array.from(state.registry.keys());
     },
-    has(key2) {
-      return state.registry.has(key2);
+    has(key) {
+      return state.registry.has(key);
     },
     size() {
       return state.registry.size;
     },
     async clear() {
       const keys = this.keys();
-      for (const key2 of keys) {
-        await this.delete(key2);
+      for (const key of keys) {
+        await this.delete(key);
       }
       return this;
     }
   };
 };
-const STRAPI_DEFAULTS = {
-  offset: {
-    start: 0,
-    limit: 10
-  },
-  page: {
-    page: 1,
-    pageSize: 10
-  }
-};
-const paginationAttributes = ["start", "limit", "page", "pageSize"];
-const withMaxLimit = (limit, maxLimit = -1) => {
-  if (maxLimit === -1 || limit < maxLimit) {
-    return limit;
-  }
-  return maxLimit;
-};
-const ensureMinValues = ({ start, limit }) => ({
-  start: Math.max(start, 0),
-  limit: limit === -1 ? limit : Math.max(limit, 1)
-});
-const ensureMaxValues = (maxLimit = -1) => ({ start, limit }) => ({
-  start,
-  limit: withMaxLimit(limit, maxLimit)
-});
-const withNoLimit = (pagination2, maxLimit = -1) => ({
-  ...pagination2,
-  limit: pagination2.limit === -1 ? maxLimit : pagination2.limit
-});
-const withDefaultPagination = (args, { defaults: defaults2 = {}, maxLimit = -1 } = {}) => {
-  const defaultValues = merge(STRAPI_DEFAULTS, defaults2);
-  const usePagePagination = !isNil(args.page) || !isNil(args.pageSize);
-  const useOffsetPagination = !isNil(args.start) || !isNil(args.limit);
-  const ensureValidValues = pipe(ensureMinValues, ensureMaxValues(maxLimit));
-  if (!usePagePagination && !useOffsetPagination) {
-    return merge(args, ensureValidValues(defaultValues.offset));
-  }
-  if (usePagePagination && useOffsetPagination) {
-    throw new PaginationError("Cannot use both page & offset pagination in the same query");
-  }
-  const pagination2 = {
-    start: 0,
-    limit: 0
-  };
-  if (useOffsetPagination) {
-    const { start, limit } = merge(defaultValues.offset, args);
-    Object.assign(pagination2, { start, limit });
-  }
-  if (usePagePagination) {
-    const { page, pageSize } = merge(defaultValues.page, {
-      ...args,
-      pageSize: Math.max(1, args.pageSize ?? 0)
-    });
-    Object.assign(pagination2, {
-      start: (page - 1) * pageSize,
-      limit: pageSize
-    });
-  }
-  Object.assign(pagination2, withNoLimit(pagination2, maxLimit));
-  const replacePaginationAttributes = pipe(
-    // Remove pagination attributes
-    omit(paginationAttributes),
-    // Merge the object with the new pagination + ensure minimum & maximum values
-    merge(ensureValidValues(pagination2))
-  );
-  return replacePaginationAttributes(args);
-};
-const pagination = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  withDefaultPagination
-}, Symbol.toStringTag, { value: "Module" }));
-function pipeAsync(...fns) {
+function pipe(...fns) {
   const [firstFn, ...fnRest] = fns;
   return async (...args) => {
     let res = await firstFn.apply(firstFn, args);
@@ -1155,34 +526,37 @@ function pipeAsync(...fns) {
     return res;
   };
 }
-const mapAsync = curry(pMap);
-const reduceAsync = (mixedArray) => async (iteratee, initialValue) => {
-  let acc2 = initialValue;
+const map = curry(pMap);
+const reduce = (mixedArray) => async (iteratee, initialValue) => {
+  let acc = initialValue;
   for (let i = 0; i < mixedArray.length; i += 1) {
-    acc2 = await iteratee(acc2, await mixedArray[i], i);
+    acc = await iteratee(acc, await mixedArray[i], i);
   }
-  return acc2;
-};
-const forEachAsync = async (array, func, options) => {
-  await pMap(array, func, options);
+  return acc;
 };
-const visitor$7 = ({ key: key2, attribute }, { remove: remove2 }) => {
+const async = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  map,
+  pipe,
+  reduce
+}, Symbol.toStringTag, { value: "Module" }));
+const visitor$8 = ({ key, attribute }, { remove: remove2 }) => {
   if (attribute?.type === "password") {
-    remove2(key2);
+    remove2(key);
   }
 };
-const visitor$6 = ({ schema, key: key2, attribute }, { remove: remove2 }) => {
+const visitor$7 = ({ schema, key, attribute }, { remove: remove2 }) => {
   if (!attribute) {
     return;
   }
-  const isPrivate = attribute.private === true || isPrivateAttribute(schema, key2);
+  const isPrivate = attribute.private === true || isPrivateAttribute(schema, key);
   if (isPrivate) {
-    remove2(key2);
+    remove2(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: key2, attribute, schema }, { remove: remove2, set }) => {
+const removeRestrictedRelations = (auth) => async ({ data, key, attribute, schema }, { remove: remove2, set }) => {
   if (!attribute) {
     return;
   }
@@ -1192,7 +566,7 @@ const removeRestrictedRelations = (auth) => async ({ data, key: key2, attribute,
   }
   const handleMorphRelation = async () => {
     const newMorphValue = [];
-    for (const element of data[key2]) {
+    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) {
@@ -1200,19 +574,19 @@ const removeRestrictedRelations = (auth) => async ({ data, key: key2, attribute,
       }
     }
     if (newMorphValue.length === 0) {
-      remove2(key2);
+      remove2(key);
     } else {
-      set(key2, newMorphValue);
+      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) {
-      remove2(key2);
+      remove2(key);
     }
   };
-  const isCreatorRelation = [CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE$1].includes(key2);
+  const isCreatorRelation = [CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE$1].includes(key);
   if (isMorphToRelationalAttribute(attribute)) {
     await handleMorphRelation();
     return;
@@ -1233,21 +607,21 @@ const hasAccessToSomeScopes$1 = async (scopes, auth) => {
   }
   return false;
 };
-const visitor$5 = ({ key: key2, attribute }, { remove: remove2 }) => {
+const visitor$6 = ({ key, attribute }, { remove: remove2 }) => {
   if (isMorphToRelationalAttribute(attribute)) {
-    remove2(key2);
+    remove2(key);
   }
 };
-const visitor$4 = ({ key: key2, attribute }, { remove: remove2 }) => {
+const visitor$5 = ({ key, attribute }, { remove: remove2 }) => {
   if (isDynamicZoneAttribute(attribute)) {
-    remove2(key2);
+    remove2(key);
   }
 };
-const removeDisallowedFields = (allowedFields = null) => ({ key: key2, path: { attribute: path } }, { remove: remove2 }) => {
+const removeDisallowedFields = (allowedFields = null) => ({ key, path: { attribute: path } }, { remove: remove2 }) => {
   if (allowedFields === null) {
     return;
   }
-  if (!(isArray(allowedFields) && allowedFields.every(isString$1))) {
+  if (!(isArray(allowedFields) && allowedFields.every(isString))) {
     throw new TypeError(
       `Expected array of strings for allowedFields but got "${typeof allowedFields}"`
     );
@@ -1262,42 +636,52 @@ const removeDisallowedFields = (allowedFields = null) => ({ key: key2, path: { a
   if (isPathAllowed) {
     return;
   }
-  remove2(key2);
+  remove2(key);
 };
 const getContainedPaths$1 = (path) => {
   const parts = toPath(path);
-  return parts.reduce((acc2, value2, index2, list) => {
-    return [...acc2, list.slice(0, index2 + 1).join(".")];
+  return parts.reduce((acc, value, index2, list) => {
+    return [...acc, list.slice(0, index2 + 1).join(".")];
   }, []);
 };
-const removeRestrictedFields = (restrictedFields = null) => ({ key: key2, path: { attribute: path } }, { remove: remove2 }) => {
+const removeRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path } }, { remove: remove2 }) => {
   if (restrictedFields === null) {
-    remove2(key2);
+    remove2(key);
     return;
   }
-  if (!(isArray(restrictedFields) && restrictedFields.every(isString$1))) {
+  if (!(isArray(restrictedFields) && restrictedFields.every(isString))) {
     throw new TypeError(
       `Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`
     );
   }
   if (restrictedFields.includes(path)) {
-    remove2(key2);
+    remove2(key);
     return;
   }
   const isRestrictedNested = restrictedFields.some(
     (allowedPath) => path?.toString().startsWith(`${allowedPath}.`)
   );
   if (isRestrictedNested) {
-    remove2(key2);
+    remove2(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$4,
-  removeMorphToRelations: visitor$5,
-  removePassword: visitor$7,
-  removePrivate: visitor$6,
+  removeDynamicZones: visitor$5,
+  removeMorphToRelations: visitor$6,
+  removePassword: visitor$8,
+  removePrivate: visitor$7,
   removeRestrictedFields,
   removeRestrictedRelations
 }, Symbol.toStringTag, { value: "Module" }));
@@ -1334,85 +718,85 @@ const traverseEntity = async (visitor2, options, entity) => {
   const visitorUtils = createVisitorUtils({ data: copy });
   const keys = Object.keys(copy);
   for (let i = 0; i < keys.length; i += 1) {
-    const key2 = keys[i];
-    const attribute = schema.attributes[key2];
+    const key = keys[i];
+    const attribute = schema.attributes[key];
     if (isNil(attribute)) {
       continue;
     }
     const newPath = { ...path };
-    newPath.raw = isNil(path.raw) ? key2 : `${path.raw}.${key2}`;
+    newPath.raw = isNil(path.raw) ? key : `${path.raw}.${key}`;
     if (!isNil(attribute)) {
-      newPath.attribute = isNil(path.attribute) ? key2 : `${path.attribute}.${key2}`;
+      newPath.attribute = isNil(path.attribute) ? key : `${path.attribute}.${key}`;
     }
     const visitorOptions = {
       data: copy,
       schema,
-      key: key2,
-      value: copy[key2],
+      key,
+      value: copy[key],
       attribute,
       path: newPath
     };
     await visitor2(visitorOptions, visitorUtils);
-    const value2 = copy[key2];
-    if (isNil(value2)) {
+    const value = copy[key];
+    if (isNil(value)) {
       continue;
     }
     if (isRelationalAttribute(attribute)) {
       const isMorphRelation = attribute.relation.toLowerCase().startsWith("morph");
       const method = isMorphRelation ? traverseMorphRelationTarget : traverseRelationTarget(strapi.getModel(attribute.target));
-      if (isArray(value2)) {
-        const res = new Array(value2.length);
-        for (let i2 = 0; i2 < value2.length; i2 += 1) {
-          res[i2] = await method(visitor2, newPath, value2[i2]);
+      if (isArray(value)) {
+        const res = new Array(value.length);
+        for (let i2 = 0; i2 < value.length; i2 += 1) {
+          res[i2] = await method(visitor2, newPath, value[i2]);
         }
-        copy[key2] = res;
+        copy[key] = res;
       } else {
-        copy[key2] = await method(visitor2, newPath, value2);
+        copy[key] = await method(visitor2, newPath, value);
       }
       continue;
     }
     if (isMediaAttribute(attribute)) {
-      if (isArray(value2)) {
-        const res = new Array(value2.length);
-        for (let i2 = 0; i2 < value2.length; i2 += 1) {
-          res[i2] = await traverseMediaTarget(visitor2, newPath, value2[i2]);
+      if (isArray(value)) {
+        const res = new Array(value.length);
+        for (let i2 = 0; i2 < value.length; i2 += 1) {
+          res[i2] = await traverseMediaTarget(visitor2, newPath, value[i2]);
         }
-        copy[key2] = res;
+        copy[key] = res;
       } else {
-        copy[key2] = await traverseMediaTarget(visitor2, newPath, value2);
+        copy[key] = await traverseMediaTarget(visitor2, newPath, value);
       }
       continue;
     }
     if (attribute.type === "component") {
       const targetSchema = strapi.getModel(attribute.component);
-      if (isArray(value2)) {
-        const res = new Array(value2.length);
-        for (let i2 = 0; i2 < value2.length; i2 += 1) {
-          res[i2] = await traverseComponent(visitor2, newPath, targetSchema, value2[i2]);
+      if (isArray(value)) {
+        const res = new Array(value.length);
+        for (let i2 = 0; i2 < value.length; i2 += 1) {
+          res[i2] = await traverseComponent(visitor2, newPath, targetSchema, value[i2]);
         }
-        copy[key2] = res;
+        copy[key] = res;
       } else {
-        copy[key2] = await traverseComponent(visitor2, newPath, targetSchema, value2);
+        copy[key] = await traverseComponent(visitor2, newPath, targetSchema, value);
       }
       continue;
     }
-    if (attribute.type === "dynamiczone" && isArray(value2)) {
-      const res = new Array(value2.length);
-      for (let i2 = 0; i2 < value2.length; i2 += 1) {
-        res[i2] = await visitDynamicZoneEntry(visitor2, newPath, value2[i2]);
+    if (attribute.type === "dynamiczone" && isArray(value)) {
+      const res = new Array(value.length);
+      for (let i2 = 0; i2 < value.length; i2 += 1) {
+        res[i2] = await visitDynamicZoneEntry(visitor2, newPath, value[i2]);
       }
-      copy[key2] = res;
+      copy[key] = res;
       continue;
     }
   }
   return copy;
 };
 const createVisitorUtils = ({ data }) => ({
-  remove(key2) {
-    delete data[key2];
+  remove(key) {
+    delete data[key];
   },
-  set(key2, value2) {
-    data[key2] = value2;
+  set(key, value) {
+    data[key] = value;
   }
 });
 const traverseEntity$1 = curry(traverseEntity);
@@ -1441,37 +825,37 @@ const traverseFactory = () => {
     }
     let out = utils2.transform(data);
     const keys = utils2.keys(out);
-    for (const key2 of keys) {
-      const attribute = schema?.attributes?.[key2] ?? // FIX: Needed to not break existing behavior on the API.
+    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[key2]];
+      schema?.attributes?.[strapi.db.metadata.get(schema?.uid).columnToAttribute[key]];
       const newPath = { ...path };
-      newPath.raw = isNil(path.raw) ? key2 : `${path.raw}.${key2}`;
+      newPath.raw = isNil(path.raw) ? key : `${path.raw}.${key}`;
       if (!isNil(attribute)) {
-        newPath.attribute = isNil(path.attribute) ? key2 : `${path.attribute}.${key2}`;
+        newPath.attribute = isNil(path.attribute) ? key : `${path.attribute}.${key}`;
       }
       const visitorOptions = {
-        key: key2,
-        value: utils2.get(key2, out),
+        key,
+        value: utils2.get(key, out),
         attribute,
         schema,
         path: newPath,
         data: out
       };
       const transformUtils = {
-        remove(key22) {
-          out = utils2.remove(key22, out);
+        remove(key2) {
+          out = utils2.remove(key2, out);
         },
-        set(key22, value22) {
-          out = utils2.set(key22, value22, out);
+        set(key2, value2) {
+          out = utils2.set(key2, value2, out);
         },
         recurse: traverse
       };
       await visitor2(visitorOptions, pick(["remove", "set"], transformUtils));
-      const value2 = utils2.get(key2, out);
+      const value = utils2.get(key, out);
       const createContext = () => ({
-        key: key2,
-        value: value2,
+        key,
+        value,
         attribute,
         schema,
         path: newPath,
@@ -1530,7 +914,7 @@ const traverseFactory = () => {
     }
   };
 };
-const isObj$2 = (value2) => isObject(value2);
+const isObj$2 = (value) => isObject(value);
 const filters = traverseFactory().intercept(
   // Intercept filters arrays and apply the traversal to each one individually
   isArray,
@@ -1551,50 +935,50 @@ const filters = traverseFactory().intercept(
   }
 ).parse(isObj$2, () => ({
   transform: cloneDeep,
-  remove(key2, data) {
-    return omit(key2, data);
+  remove(key, data) {
+    return omit(key, data);
   },
-  set(key2, value2, data) {
-    return { ...data, [key2]: value2 };
+  set(key, value, data) {
+    return { ...data, [key]: value };
   },
   keys(data) {
     return Object.keys(data);
   },
-  get(key2, data) {
-    return data[key2];
+  get(key, data) {
+    return data[key];
   }
-})).ignore(({ value: value2 }) => isNil(value2)).on(
+})).ignore(({ value }) => isNil(value)).on(
   ({ attribute }) => isNil(attribute),
-  async ({ key: key2, visitor: visitor2, path, value: value2, schema }, { set, recurse }) => {
-    set(key2, await recurse(visitor2, { schema, path }, value2));
+  async ({ key, visitor: visitor2, path, value, schema }, { set, recurse }) => {
+    set(key, await recurse(visitor2, { schema, path }, value));
   }
-).onRelation(async ({ key: key2, attribute, visitor: visitor2, path, value: value2 }, { set, recurse }) => {
+).onRelation(async ({ key, attribute, visitor: visitor2, path, value }, { 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 }, value2);
-  set(key2, newValue);
-}).onComponent(async ({ key: key2, attribute, visitor: visitor2, path, value: value2 }, { set, recurse }) => {
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, 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 }, value2);
-  set(key2, newValue);
-}).onMedia(async ({ key: key2, visitor: visitor2, path, value: value2 }, { set, recurse }) => {
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  set(key, newValue);
+}).onMedia(async ({ key, visitor: visitor2, path, value }, { set, recurse }) => {
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value2);
-  set(key2, newValue);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  set(key, newValue);
 });
 const traverseQueryFilters = curry(filters.traverse);
 const ORDERS = { asc: "asc", desc: "desc" };
 const ORDER_VALUES = Object.values(ORDERS);
-const isSortOrder = (value2) => ORDER_VALUES.includes(value2.toLowerCase());
-const isStringArray$3 = (value2) => Array.isArray(value2) && value2.every(isString$1);
-const isObjectArray = (value2) => Array.isArray(value2) && value2.every(isObject);
-const isNestedSorts = (value2) => isString$1(value2) && value2.split(",").length > 1;
-const isObj$1 = (value2) => isObject(value2);
+const isSortOrder = (value) => ORDER_VALUES.includes(value.toLowerCase());
+const isStringArray$3 = (value) => Array.isArray(value) && value.every(isString);
+const isObjectArray = (value) => Array.isArray(value) && value.every(isObject);
+const isNestedSorts = (value) => isString(value) && value.split(",").length > 1;
+const isObj$1 = (value) => isObject(value);
 const sort = traverseFactory().intercept(
   // String with chained sorts (foo,bar,foobar) => split, map(recurse), then recompose
   isNestedSorts,
@@ -1619,221 +1003,240 @@ const sort = traverseFactory().intercept(
       (res) => res.filter((nestedSort) => !isEmpty(nestedSort))
     );
   }
-).parse(isString$1, () => {
-  const tokenize = pipe(split("."), map(split(":")), flatten);
+).parse(isString, () => {
+  const tokenize = pipe$1(split("."), map$1(split(":")), flatten);
   const recompose = (parts) => {
     if (parts.length === 0) {
       return void 0;
     }
-    return parts.reduce((acc2, part) => {
+    return parts.reduce((acc, part) => {
       if (isEmpty(part)) {
-        return acc2;
+        return acc;
       }
-      if (acc2 === "") {
+      if (acc === "") {
         return part;
       }
-      return isSortOrder(part) ? `${acc2}:${part}` : `${acc2}.${part}`;
+      return isSortOrder(part) ? `${acc}:${part}` : `${acc}.${part}`;
     }, "");
   };
   return {
     transform: trim,
-    remove(key2, data) {
+    remove(key, data) {
       const [root] = tokenize(data);
-      return root === key2 ? void 0 : data;
+      return root === key ? void 0 : data;
     },
-    set(key2, value2, data) {
+    set(key, value, data) {
       const [root] = tokenize(data);
-      if (root !== key2) {
+      if (root !== key) {
         return data;
       }
-      return isNil(value2) ? root : `${root}.${value2}`;
+      return isNil(value) ? root : `${root}.${value}`;
     },
     keys(data) {
       const v = first(tokenize(data));
       return v ? [v] : [];
     },
-    get(key2, data) {
+    get(key, data) {
       const [root, ...rest] = tokenize(data);
-      return key2 === root ? recompose(rest) : void 0;
+      return key === root ? recompose(rest) : void 0;
     }
   };
 }).parse(isObj$1, () => ({
   transform: cloneDeep,
-  remove(key2, data) {
-    const { [key2]: ignored, ...rest } = data;
+  remove(key, data) {
+    const { [key]: ignored, ...rest } = data;
     return rest;
   },
-  set(key2, value2, data) {
-    return { ...data, [key2]: value2 };
+  set(key, value, data) {
+    return { ...data, [key]: value };
   },
   keys(data) {
     return Object.keys(data);
   },
-  get(key2, data) {
-    return data[key2];
+  get(key, data) {
+    return data[key];
   }
-})).onRelation(async ({ key: key2, value: value2, attribute, visitor: visitor2, path }, { set, recurse }) => {
+})).onRelation(async ({ key, value, attribute, visitor: visitor2, path }, { 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 }, value2);
-  set(key2, newValue);
-}).onMedia(async ({ key: key2, path, visitor: visitor2, value: value2 }, { recurse, set }) => {
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  set(key, newValue);
+}).onMedia(async ({ key, path, visitor: visitor2, value }, { recurse, set }) => {
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value2);
-  set(key2, newValue);
-}).onComponent(async ({ key: key2, value: value2, visitor: visitor2, path, attribute }, { recurse, set }) => {
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, 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 }, value2);
-  set(key2, newValue);
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  set(key, newValue);
 });
 const traverseQuerySort = curry(sort.traverse);
 const isKeyword = (keyword) => {
-  return ({ key: key2, attribute }) => {
-    return !attribute && keyword === key2;
+  return ({ key, attribute }) => {
+    return !attribute && keyword === key;
   };
 };
-const isStringArray$2 = (value2) => isArray(value2) && value2.every(isString$1);
-const isWildCardConstant = (value2) => value2 === "*";
-const isObj = (value2) => isObject(value2);
+const isStringArray$2 = (value) => isArray(value) && value.every(isString);
+const isObj = (value) => isObject(value);
 const populate = traverseFactory().intercept(isStringArray$2, async (visitor2, options, populate2, { recurse }) => {
   const visitedPopulate = await Promise.all(
     populate2.map((nestedPopulate) => recurse(visitor2, options, nestedPopulate))
   );
   return visitedPopulate.filter((item) => !isNil(item));
-}).intercept(isWildCardConstant, (visitor2, options, _data, { recurse }) => {
-  const attributes = options.schema?.attributes;
-  if (!attributes) {
-    return "*";
-  }
-  const parsedPopulate = Object.entries(attributes).filter(([, value2]) => ["relation", "component", "dynamiczone", "media"].includes(value2.type)).reduce((acc2, [key2]) => ({ ...acc2, [key2]: true }), {});
-  return recurse(visitor2, options, parsedPopulate);
-}).parse(isString$1, () => {
+}).parse(
+  (value) => value === "*",
+  () => ({
+    /**
+     * Since value is '*', we don't need to transform it
+     */
+    transform: identity,
+    /**
+     * '*' isn't a key/value structure, so regardless
+     *  of the given key, it returns the data ('*')
+     */
+    get: (_key, data) => data,
+    /**
+     * '*' isn't a key/value structure, so regardless
+     * of the given `key`, use `value` as the new `data`
+     */
+    set: (_key, value) => value,
+    /**
+     * '*' isn't a key/value structure, but we need to simulate at least one to enable
+     * the data traversal. We're using '' since it represents a falsy string value
+     */
+    keys: constant([""]),
+    /**
+     * Removing '*' means setting it to undefined, regardless of the given key
+     */
+    remove: constant(void 0)
+  })
+).parse(isString, () => {
   const tokenize = split(".");
   const recompose = join(".");
   return {
     transform: trim,
-    remove(key2, data) {
+    remove(key, data) {
       const [root] = tokenize(data);
-      return root === key2 ? void 0 : data;
+      return root === key ? void 0 : data;
     },
-    set(key2, value2, data) {
+    set(key, value, data) {
       const [root] = tokenize(data);
-      if (root !== key2) {
+      if (root !== key) {
         return data;
       }
-      return isNil(value2) || isEmpty(value2) ? root : `${root}.${value2}`;
+      return isNil(value) || isEmpty(value) ? root : `${root}.${value}`;
     },
     keys(data) {
       const v = first(tokenize(data));
       return v ? [v] : [];
     },
-    get(key2, data) {
+    get(key, data) {
       const [root, ...rest] = tokenize(data);
-      return key2 === root ? recompose(rest) : void 0;
+      return key === root ? recompose(rest) : void 0;
     }
   };
 }).parse(isObj, () => ({
   transform: cloneDeep,
-  remove(key2, data) {
-    const { [key2]: ignored, ...rest } = data;
+  remove(key, data) {
+    const { [key]: ignored, ...rest } = data;
     return rest;
   },
-  set(key2, value2, data) {
-    return { ...data, [key2]: value2 };
+  set(key, value, data) {
+    return { ...data, [key]: value };
   },
   keys(data) {
     return Object.keys(data);
   },
-  get(key2, data) {
-    return data[key2];
+  get(key, data) {
+    return data[key];
   }
-})).ignore(({ key: key2, attribute }) => {
-  return ["sort", "filters", "fields"].includes(key2) && !attribute;
+})).ignore(({ key, attribute }) => {
+  return ["sort", "filters", "fields"].includes(key) && !attribute;
 }).on(
   // Handle recursion on populate."populate"
   isKeyword("populate"),
-  async ({ key: key2, visitor: visitor2, path, value: value2, schema }, { set, recurse }) => {
-    const newValue = await recurse(visitor2, { schema, path }, value2);
-    set(key2, newValue);
+  async ({ key, visitor: visitor2, path, value, schema }, { set, recurse }) => {
+    const newValue = await recurse(visitor2, { schema, path }, value);
+    set(key, newValue);
   }
-).on(isKeyword("on"), async ({ key: key2, visitor: visitor2, path, value: value2 }, { set, recurse }) => {
+).on(isKeyword("on"), async ({ key, visitor: visitor2, path, value }, { set, recurse }) => {
   const newOn = {};
-  if (!isObj(value2)) {
+  if (!isObj(value)) {
     return;
   }
-  for (const [uid, subPopulate] of Object.entries(value2)) {
+  for (const [uid, subPopulate] of Object.entries(value)) {
     const model = strapi.getModel(uid);
     const newPath = { ...path, raw: `${path.raw}[${uid}]` };
     newOn[uid] = await recurse(visitor2, { schema: model, path: newPath }, subPopulate);
   }
-  set(key2, newOn);
-}).onRelation(async ({ key: key2, value: value2, attribute, visitor: visitor2, path, schema }, { set, recurse }) => {
-  if (isNil(value2)) {
+  set(key, newOn);
+}).onRelation(async ({ key, value, attribute, visitor: visitor2, path, schema }, { set, recurse }) => {
+  if (isNil(value)) {
     return;
   }
   if (isMorphToRelationalAttribute(attribute)) {
-    if (!isObject(value2) || !("on" in value2 && isObject(value2?.on))) {
+    if (!isObject(value) || !("on" in value && isObject(value?.on))) {
       return;
     }
-    const newValue2 = await recurse(visitor2, { schema, path }, { on: value2?.on });
-    set(key2, { on: newValue2 });
+    const newValue2 = await recurse(visitor2, { schema, path }, { on: value?.on });
+    set(key, { on: newValue2 });
   }
   const targetSchemaUID = attribute.target;
   const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value2);
-  set(key2, newValue);
-}).onMedia(async ({ key: key2, path, visitor: visitor2, value: value2 }, { recurse, set }) => {
-  if (isNil(value2)) {
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  set(key, newValue);
+}).onMedia(async ({ key, path, visitor: visitor2, value }, { recurse, set }) => {
+  if (isNil(value)) {
     return;
   }
   const targetSchemaUID = "plugin::upload.file";
   const targetSchema = strapi.getModel(targetSchemaUID);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value2);
-  set(key2, newValue);
-}).onComponent(async ({ key: key2, value: value2, visitor: visitor2, path, attribute }, { recurse, set }) => {
-  if (isNil(value2)) {
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  set(key, newValue);
+}).onComponent(async ({ key, value, visitor: visitor2, path, attribute }, { recurse, set }) => {
+  if (isNil(value)) {
     return;
   }
   const targetSchema = strapi.getModel(attribute.component);
-  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value2);
-  set(key2, newValue);
-}).onDynamicZone(async ({ key: key2, value: value2, attribute, schema, visitor: visitor2, path }, { set, recurse }) => {
-  if (isNil(value2)) {
+  const newValue = await recurse(visitor2, { schema: targetSchema, path }, value);
+  set(key, newValue);
+}).onDynamicZone(async ({ key, value, attribute, schema, visitor: visitor2, path }, { set, recurse }) => {
+  if (isNil(value)) {
     return;
   }
-  if (isObject(value2)) {
+  if (isObject(value)) {
     const { components } = attribute;
     const newValue = {};
-    let newProperties = omit("on", value2);
+    let newProperties = omit("on", value);
     for (const componentUID of components) {
       const componentSchema = strapi.getModel(componentUID);
-      const properties = await recurse(visitor2, { schema: componentSchema, path }, value2);
+      const properties = await recurse(visitor2, { schema: componentSchema, path }, value);
       newProperties = merge(newProperties, properties);
     }
     Object.assign(newValue, newProperties);
-    if ("on" in value2 && value2.on) {
-      const newOn = await recurse(visitor2, { schema, path }, { on: value2.on });
+    if ("on" in value && value.on) {
+      const newOn = await recurse(visitor2, { schema, path }, { on: value.on });
       Object.assign(newValue, newOn);
     }
-    set(key2, newValue);
+    set(key, newValue);
   } else {
-    const newValue = await recurse(visitor2, { schema, path }, value2);
-    set(key2, newValue);
+    const newValue = await recurse(visitor2, { schema, path }, value);
+    set(key, newValue);
   }
 });
 const traverseQueryPopulate = curry(populate.traverse);
-const isStringArray$1 = (value2) => isArray(value2) && value2.every(isString$1);
+const isStringArray$1 = (value) => isArray(value) && value.every(isString);
 const fields = traverseFactory().intercept(isStringArray$1, async (visitor2, options, fields2, { recurse }) => {
   return Promise.all(fields2.map((field) => recurse(visitor2, options, field)));
-}).intercept((value2) => eq("*", value2), constant("*")).parse(isString$1, () => ({
+}).intercept((value) => eq("*", value), constant("*")).parse(isString, () => ({
   transform: trim,
-  remove(key2, data) {
-    return data === key2 ? void 0 : data;
+  remove(key, data) {
+    return data === key ? void 0 : data;
   },
   set(_key, _value, data) {
     return data;
@@ -1841,8 +1244,8 @@ const fields = traverseFactory().intercept(isStringArray$1, async (visitor2, opt
   keys(data) {
     return [data];
   },
-  get(key2, data) {
-    return key2 === data ? data : void 0;
+  get(key, data) {
+    return key === data ? data : void 0;
   }
 }));
 const traverseQueryFields = curry(fields.traverse);
@@ -1901,31 +1304,32 @@ const OPERATORS = {
   array: ARRAY_OPERATORS
 };
 const OPERATORS_LOWERCASE = Object.fromEntries(
-  Object.entries(OPERATORS).map(([key2, values]) => [
-    key2,
-    values.map((value2) => value2.toLowerCase())
+  Object.entries(OPERATORS).map(([key, values]) => [
+    key,
+    values.map((value) => value.toLowerCase())
   ])
 );
-const isObjKey = (key2, obj2) => {
-  return key2 in obj2;
+const isObjKey = (key, obj) => {
+  return key in obj;
 };
-const isOperatorOfType = (type, key2, ignoreCase = false) => {
+const isOperatorOfType = (type, key, ignoreCase = false) => {
   if (ignoreCase) {
-    return OPERATORS_LOWERCASE[type]?.includes(key2.toLowerCase()) ?? false;
+    return OPERATORS_LOWERCASE[type]?.includes(key.toLowerCase()) ?? false;
   }
   if (isObjKey(type, OPERATORS)) {
-    return OPERATORS[type]?.includes(key2) ?? false;
+    return OPERATORS[type]?.includes(key) ?? false;
   }
   return false;
 };
-const isOperator = (key2, ignoreCase = false) => {
-  return Object.keys(OPERATORS).some((type) => isOperatorOfType(type, key2, ignoreCase));
+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) {
     throw new Error("Missing schema in sanitizePasswords");
   }
-  return traverseEntity$1(visitor$7, { schema }, entity);
+  return traverseEntity$1(visitor$8, { schema }, entity);
 };
 const defaultSanitizeOutput = async (schema, entity) => {
   if (!schema) {
@@ -1933,8 +1337,8 @@ const defaultSanitizeOutput = async (schema, entity) => {
   }
   return traverseEntity$1(
     (...args) => {
+      visitor$8(...args);
       visitor$7(...args);
-      visitor$6(...args);
     },
     { schema },
     entity
@@ -1944,33 +1348,33 @@ const defaultSanitizeFilters = curry((schema, filters2) => {
   if (!schema) {
     throw new Error("Missing schema in defaultSanitizeFilters");
   }
-  return pipeAsync(
+  return pipe(
     // Remove keys that are not attributes or valid operators
     traverseQueryFilters(
-      ({ key: key2, attribute }, { remove: remove2 }) => {
+      ({ key, attribute }, { remove: remove2 }) => {
         const isAttribute = !!attribute;
-        if (key2 === "id") {
+        if ([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3].includes(key)) {
           return;
         }
-        if (!isAttribute && !isOperator(key2)) {
-          remove2(key2);
+        if (!isAttribute && !isOperator(key)) {
+          remove2(key);
         }
       },
       { schema }
     ),
     // Remove dynamic zones from filters
-    traverseQueryFilters(visitor$4, { schema }),
-    // Remove morpTo relations from filters
     traverseQueryFilters(visitor$5, { schema }),
+    // Remove morpTo relations from filters
+    traverseQueryFilters(visitor$6, { schema }),
     // Remove passwords from filters
-    traverseQueryFilters(visitor$7, { schema }),
+    traverseQueryFilters(visitor$8, { schema }),
     // Remove private from filters
-    traverseQueryFilters(visitor$6, { schema }),
+    traverseQueryFilters(visitor$7, { schema }),
     // Remove empty objects
     traverseQueryFilters(
-      ({ key: key2, value: value2 }, { remove: remove2 }) => {
-        if (isObject(value2) && isEmpty(value2)) {
-          remove2(key2);
+      ({ key, value }, { remove: remove2 }) => {
+        if (isObject(value) && isEmpty(value)) {
+          remove2(key);
         }
       },
       { schema }
@@ -1981,35 +1385,35 @@ const defaultSanitizeSort = curry((schema, sort2) => {
   if (!schema) {
     throw new Error("Missing schema in defaultSanitizeSort");
   }
-  return pipeAsync(
+  return pipe(
     // Remove non attribute keys
     traverseQuerySort(
-      ({ key: key2, attribute }, { remove: remove2 }) => {
-        if (key2 === "id") {
+      ({ key, attribute }, { remove: remove2 }) => {
+        if ([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3].includes(key)) {
           return;
         }
         if (!attribute) {
-          remove2(key2);
+          remove2(key);
         }
       },
       { schema }
     ),
     // Remove dynamic zones from sort
-    traverseQuerySort(visitor$4, { schema }),
-    // Remove morpTo relations from sort
     traverseQuerySort(visitor$5, { schema }),
-    // Remove private from sort
+    // Remove morpTo relations from sort
     traverseQuerySort(visitor$6, { schema }),
-    // Remove passwords from filters
+    // Remove private from sort
     traverseQuerySort(visitor$7, { schema }),
+    // Remove passwords from filters
+    traverseQuerySort(visitor$8, { schema }),
     // Remove keys for empty non-scalar values
     traverseQuerySort(
-      ({ key: key2, attribute, value: value2 }, { remove: remove2 }) => {
-        if (key2 === "id") {
+      ({ key, attribute, value }, { remove: remove2 }) => {
+        if ([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3].includes(key)) {
           return;
         }
-        if (!isScalarAttribute(attribute) && isEmpty(value2)) {
-          remove2(key2);
+        if (!isScalarAttribute(attribute) && isEmpty(value)) {
+          remove2(key);
         }
       },
       { schema }
@@ -2020,51 +1424,55 @@ const defaultSanitizeFields = curry((schema, fields2) => {
   if (!schema) {
     throw new Error("Missing schema in defaultSanitizeFields");
   }
-  return pipeAsync(
+  return pipe(
     // Only keep scalar attributes
     traverseQueryFields(
-      ({ key: key2, attribute }, { remove: remove2 }) => {
-        if (key2 === "id") {
+      ({ key, attribute }, { remove: remove2 }) => {
+        if ([ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE$3].includes(key)) {
           return;
         }
         if (isNil(attribute) || !isScalarAttribute(attribute)) {
-          remove2(key2);
+          remove2(key);
         }
       },
       { schema }
     ),
     // Remove private fields
-    traverseQueryFields(visitor$6, { schema }),
-    // Remove password fields
     traverseQueryFields(visitor$7, { schema }),
+    // Remove password fields
+    traverseQueryFields(visitor$8, { schema }),
     // Remove nil values from fields array
-    (value2) => isArray(value2) ? value2.filter((field) => !isNil(field)) : value2
+    (value) => isArray(value) ? value.filter((field) => !isNil(field)) : value
   )(fields2);
 });
 const defaultSanitizePopulate = curry((schema, populate2) => {
   if (!schema) {
     throw new Error("Missing schema in defaultSanitizePopulate");
   }
-  return pipeAsync(
+  return pipe(
+    traverseQueryPopulate(visitor$4, { schema }),
     traverseQueryPopulate(
-      async ({ key: key2, value: value2, schema: schema2, attribute }, { set }) => {
+      async ({ key, value, schema: schema2, attribute }, { set }) => {
         if (attribute) {
           return;
         }
-        if (key2 === "sort") {
-          set(key2, await defaultSanitizeSort(schema2, value2));
+        if (key === "sort") {
+          set(key, await defaultSanitizeSort(schema2, value));
         }
-        if (key2 === "filters") {
-          set(key2, await defaultSanitizeFilters(schema2, value2));
+        if (key === "filters") {
+          set(key, await defaultSanitizeFilters(schema2, value));
         }
-        if (key2 === "fields") {
-          set(key2, await defaultSanitizeFields(schema2, value2));
+        if (key === "fields") {
+          set(key, await defaultSanitizeFields(schema2, value));
+        }
+        if (key === "populate") {
+          set(key, await defaultSanitizePopulate(schema2, value));
         }
       },
       { schema }
     ),
     // Remove private fields
-    traverseQueryPopulate(visitor$6, { schema })
+    traverseQueryPopulate(visitor$7, { schema })
   )(populate2);
 });
 const sanitizers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -2087,7 +1495,8 @@ const createContentAPISanitizers = () => {
     const nonWritableAttributes = getNonWritableAttributes(schema);
     const transforms = [
       // Remove first level ID in inputs
-      omit("id"),
+      omit(constants$1.ID_ATTRIBUTE),
+      omit(constants$1.DOC_ID_ATTRIBUTE),
       // Remove non-writable attributes
       traverseEntity$1(removeRestrictedFields(nonWritableAttributes), { schema })
     ];
@@ -2095,7 +1504,7 @@ const createContentAPISanitizers = () => {
       transforms.push(traverseEntity$1(removeRestrictedRelations(auth), { schema }));
     }
     strapi.sanitizers.get("content-api.input").forEach((sanitizer) => transforms.push(sanitizer(schema)));
-    return pipeAsync(...transforms)(data);
+    return pipe(...transforms)(data);
   };
   const sanitizeOutput = async (data, schema, { auth } = {}) => {
     if (!schema) {
@@ -2113,7 +1522,7 @@ const createContentAPISanitizers = () => {
       transforms.push(traverseEntity$1(removeRestrictedRelations(auth), { schema }));
     }
     strapi.sanitizers.get("content-api.output").forEach((sanitizer) => transforms.push(sanitizer(schema)));
-    return pipeAsync(...transforms)(data);
+    return pipe(...transforms)(data);
   };
   const sanitizeQuery = async (query, schema, { auth } = {}) => {
     if (!schema) {
@@ -2146,7 +1555,7 @@ const createContentAPISanitizers = () => {
     if (auth) {
       transforms.push(traverseQueryFilters(removeRestrictedRelations(auth), { schema }));
     }
-    return pipeAsync(...transforms)(filters2);
+    return pipe(...transforms)(filters2);
   };
   const sanitizeSort = (sort2, schema, { auth } = {}) => {
     if (!schema) {
@@ -2156,14 +1565,14 @@ const createContentAPISanitizers = () => {
     if (auth) {
       transforms.push(traverseQuerySort(removeRestrictedRelations(auth), { schema }));
     }
-    return pipeAsync(...transforms)(sort2);
+    return pipe(...transforms)(sort2);
   };
   const sanitizeFields = (fields2, schema) => {
     if (!schema) {
       throw new Error("Missing schema in sanitizeFields");
     }
     const transforms = [defaultSanitizeFields(schema)];
-    return pipeAsync(...transforms)(fields2);
+    return pipe(...transforms)(fields2);
   };
   const sanitizePopulate = (populate2, schema, { auth } = {}) => {
     if (!schema) {
@@ -2173,7 +1582,7 @@ const createContentAPISanitizers = () => {
     if (auth) {
       transforms.push(traverseQueryPopulate(removeRestrictedRelations(auth), { schema }));
     }
-    return pipeAsync(...transforms)(populate2);
+    return pipe(...transforms)(populate2);
   };
   return {
     input: sanitizeInput,
@@ -2191,26 +1600,134 @@ const index$1 = {
   sanitizers,
   visitors: visitors$1
 };
-const throwInvalidParam = ({ key: key2 }) => {
-  throw new ValidationError(`Invalid parameter ${key2}`);
+const formatYupInnerError = (yupError) => ({
+  path: toPath(yupError.path),
+  message: yupError.message,
+  name: yupError.name
+});
+const formatYupErrors = (yupError) => ({
+  errors: 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,
+  NotFoundError,
+  NotImplementedError,
+  PaginationError,
+  PayloadTooLargeError,
+  PolicyError,
+  RateLimitError,
+  UnauthorizedError,
+  ValidationError,
+  YupValidationError
+}, Symbol.toStringTag, { value: "Module" }));
+const throwInvalidParam = ({ key, path }) => {
+  const msg = path && path !== key ? `Invalid parameter ${key} at ${path}` : `Invalid parameter ${key}`;
+  throw new ValidationError(msg);
 };
-const visitor$3 = ({ key: key2, attribute }) => {
+const visitor$3 = ({ key, attribute, path }) => {
   if (attribute?.type === "password") {
-    throwInvalidParam({ key: key2 });
+    throwInvalidParam({ key, path: path.attribute });
   }
 };
-const visitor$2 = ({ schema, key: key2, attribute }) => {
+const visitor$2 = ({ schema, key, attribute, path }) => {
   if (!attribute) {
     return;
   }
-  const isPrivate = attribute.private === true || isPrivateAttribute(schema, key2);
+  const isPrivate = attribute.private === true || isPrivateAttribute(schema, key);
   if (isPrivate) {
-    throwInvalidParam({ key: key2 });
+    throwInvalidParam({ key, path: path.attribute });
   }
 };
 const ACTIONS_TO_VERIFY = ["find"];
 const { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = constants$1;
-const throwRestrictedRelations = (auth) => async ({ data, key: key2, attribute, schema }) => {
+const throwRestrictedRelations = (auth) => async ({ data, key, attribute, schema, path }) => {
   if (!attribute) {
     return;
   }
@@ -2219,11 +1736,11 @@ const throwRestrictedRelations = (auth) => async ({ data, key: key2, attribute,
     return;
   }
   const handleMorphRelation = async () => {
-    for (const element of data[key2]) {
+    for (const element of data[key]) {
       const scopes = ACTIONS_TO_VERIFY.map((action) => `${element.__type}.${action}`);
       const isAllowed = await hasAccessToSomeScopes(scopes, auth);
       if (!isAllowed) {
-        throwInvalidParam({ key: key2 });
+        throwInvalidParam({ key, path: path.attribute });
       }
     }
   };
@@ -2231,10 +1748,10 @@ const throwRestrictedRelations = (auth) => async ({ data, key: key2, attribute,
     const scopes = ACTIONS_TO_VERIFY.map((action) => `${attribute.target}.${action}`);
     const isAllowed = await hasAccessToSomeScopes(scopes, auth);
     if (!isAllowed) {
-      throwInvalidParam({ key: key2 });
+      throwInvalidParam({ key, path: path.attribute });
     }
   };
-  const isCreatorRelation = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(key2);
+  const isCreatorRelation = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(key);
   if (isMorphToRelationalAttribute(attribute)) {
     await handleMorphRelation();
     return;
@@ -2255,21 +1772,21 @@ const hasAccessToSomeScopes = async (scopes, auth) => {
   }
   return false;
 };
-const visitor$1 = ({ key: key2, attribute }) => {
+const visitor$1 = ({ key, attribute, path }) => {
   if (isMorphToRelationalAttribute(attribute)) {
-    throwInvalidParam({ key: key2 });
+    throwInvalidParam({ key, path: path.attribute });
   }
 };
-const visitor = ({ key: key2, attribute }) => {
+const visitor = ({ key, attribute, path }) => {
   if (isDynamicZoneAttribute(attribute)) {
-    throwInvalidParam({ key: key2 });
+    throwInvalidParam({ key, path: path.attribute });
   }
 };
-const throwDisallowedFields = (allowedFields = null) => ({ key: key2, path: { attribute: path } }) => {
+const throwDisallowedFields = (allowedFields = null) => ({ key, path: { attribute: path } }) => {
   if (allowedFields === null) {
     return;
   }
-  if (!(isArray(allowedFields) && allowedFields.every(isString$1))) {
+  if (!(isArray(allowedFields) && allowedFields.every(isString))) {
     throw new TypeError(
       `Expected array of strings for allowedFields but got "${typeof allowedFields}"`
     );
@@ -2284,31 +1801,31 @@ const throwDisallowedFields = (allowedFields = null) => ({ key: key2, path: { at
   if (isPathAllowed) {
     return;
   }
-  throwInvalidParam({ key: key2 });
+  throwInvalidParam({ key, path });
 };
 const getContainedPaths = (path) => {
   const parts = toPath(path);
-  return parts.reduce((acc2, value2, index2, list) => {
-    return [...acc2, list.slice(0, index2 + 1).join(".")];
+  return parts.reduce((acc, value, index2, list) => {
+    return [...acc, list.slice(0, index2 + 1).join(".")];
   }, []);
 };
-const throwRestrictedFields = (restrictedFields = null) => ({ key: key2, path: { attribute: path } }) => {
+const throwRestrictedFields = (restrictedFields = null) => ({ key, path: { attribute: path } }) => {
   if (restrictedFields === null) {
-    throwInvalidParam({ key: key2 });
+    throwInvalidParam({ key, path });
   }
-  if (!(isArray(restrictedFields) && restrictedFields.every(isString$1))) {
+  if (!(isArray(restrictedFields) && restrictedFields.every(isString))) {
     throw new TypeError(
       `Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`
     );
   }
   if (restrictedFields.includes(path)) {
-    throwInvalidParam({ key: key2 });
+    throwInvalidParam({ key, path });
   }
   const isRestrictedNested = restrictedFields.some(
     (allowedPath) => path?.toString().startsWith(`${allowedPath}.`)
   );
   if (isRestrictedNested) {
-    throwInvalidParam({ key: key2 });
+    throwInvalidParam({ key, path });
   }
 };
 const visitors = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -2321,6 +1838,7 @@ 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) {
     throw new Error("Missing schema in throwPasswords");
@@ -2331,16 +1849,16 @@ const defaultValidateFilters = curry((schema, filters2) => {
   if (!schema) {
     throw new Error("Missing schema in defaultValidateFilters");
   }
-  return pipeAsync(
+  return pipe(
     // keys that are not attributes or valid operators
     traverseQueryFilters(
-      ({ key: key2, attribute }) => {
-        if (key2 === "id") {
+      ({ key, attribute, path }) => {
+        if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
           return;
         }
         const isAttribute = !!attribute;
-        if (!isAttribute && !isOperator(key2)) {
-          throwInvalidParam({ key: key2 });
+        if (!isAttribute && !isOperator(key)) {
+          throwInvalidParam({ key, path: path.attribute });
         }
       },
       { schema }
@@ -2360,15 +1878,15 @@ const defaultValidateSort = curry((schema, sort2) => {
   if (!schema) {
     throw new Error("Missing schema in defaultValidateSort");
   }
-  return pipeAsync(
+  return pipe(
     // non attribute keys
     traverseQuerySort(
-      ({ key: key2, attribute }) => {
-        if (key2 === "id") {
+      ({ key, attribute, path }) => {
+        if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
           return;
         }
         if (!attribute) {
-          throwInvalidParam({ key: key2 });
+          throwInvalidParam({ key, path: path.attribute });
         }
       },
       { schema }
@@ -2383,12 +1901,12 @@ const defaultValidateSort = curry((schema, sort2) => {
     traverseQuerySort(visitor$3, { schema }),
     // keys for empty non-scalar values
     traverseQuerySort(
-      ({ key: key2, attribute, value: value2 }) => {
-        if (key2 === "id") {
+      ({ key, attribute, value, path }) => {
+        if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
           return;
         }
-        if (!isScalarAttribute(attribute) && isEmpty(value2)) {
-          throwInvalidParam({ key: key2 });
+        if (!isScalarAttribute(attribute) && isEmpty(value)) {
+          throwInvalidParam({ key, path: path.attribute });
         }
       },
       { schema }
@@ -2399,15 +1917,15 @@ const defaultValidateFields = curry((schema, fields2) => {
   if (!schema) {
     throw new Error("Missing schema in defaultValidateFields");
   }
-  return pipeAsync(
+  return pipe(
     // Only allow scalar attributes
     traverseQueryFields(
-      ({ key: key2, attribute }) => {
-        if (key2 === "id") {
+      ({ key, attribute, path }) => {
+        if ([ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE$2].includes(key)) {
           return;
         }
         if (isNil(attribute) || !isScalarAttribute(attribute)) {
-          throwInvalidParam({ key: key2 });
+          throwInvalidParam({ key, path: path.attribute });
         }
       },
       { schema }
@@ -2418,13 +1936,44 @@ const defaultValidateFields = curry((schema, fields2) => {
     traverseQueryFields(visitor$3, { schema })
   )(fields2);
 });
+const defaultValidatePopulate = curry((schema, populate2) => {
+  if (!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 }
+    ),
+    // Remove private fields
+    traverseQueryPopulate(visitor$2, { schema })
+  )(populate2);
+});
 const validators = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   defaultValidateFields,
   defaultValidateFilters,
+  defaultValidatePopulate,
   defaultValidateSort,
   throwPasswords
 }, Symbol.toStringTag, { value: "Module" }));
+const { ID_ATTRIBUTE: ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$1 } = constants$1;
 const createContentAPIValidators = () => {
   const validateInput = async (data, schema, { auth } = {}) => {
     if (!schema) {
@@ -2437,8 +1986,13 @@ const createContentAPIValidators = () => {
     const nonWritableAttributes = getNonWritableAttributes(schema);
     const transforms = [
       (data2) => {
-        if (isObject(data2) && "id" in data2) {
-          throwInvalidParam({ key: "id" });
+        if (isObject(data2)) {
+          if (ID_ATTRIBUTE$1 in data2) {
+            throwInvalidParam({ key: ID_ATTRIBUTE$1 });
+          }
+          if (DOC_ID_ATTRIBUTE$1 in data2) {
+            throwInvalidParam({ key: DOC_ID_ATTRIBUTE$1 });
+          }
         }
       },
       // non-writable attributes
@@ -2448,13 +2002,13 @@ const createContentAPIValidators = () => {
       transforms.push(traverseEntity$1(throwRestrictedRelations(auth), { schema }));
     }
     strapi.validators.get("content-api.input").forEach((validator) => transforms.push(validator(schema)));
-    pipeAsync(...transforms)(data);
+    await pipe(...transforms)(data);
   };
   const validateQuery = async (query, schema, { auth } = {}) => {
     if (!schema) {
       throw new Error("Missing schema in validateQuery");
     }
-    const { filters: filters2, sort: sort2, fields: fields2 } = query;
+    const { filters: filters2, sort: sort2, fields: fields2, populate: populate2 } = query;
     if (filters2) {
       await validateFilters(filters2, schema, { auth });
     }
@@ -2464,6 +2018,9 @@ const createContentAPIValidators = () => {
     if (fields2) {
       await validateFields(fields2, schema);
     }
+    if (populate2 && populate2 !== "*") {
+      await validatePopulate(populate2, schema);
+    }
   };
   const validateFilters = async (filters2, schema, { auth } = {}) => {
     if (!schema) {
@@ -2477,7 +2034,7 @@ const createContentAPIValidators = () => {
     if (auth) {
       transforms.push(traverseQueryFilters(throwRestrictedRelations(auth), { schema }));
     }
-    return pipeAsync(...transforms)(filters2);
+    await pipe(...transforms)(filters2);
   };
   const validateSort = async (sort2, schema, { auth } = {}) => {
     if (!schema) {
@@ -2487,21 +2044,32 @@ const createContentAPIValidators = () => {
     if (auth) {
       transforms.push(traverseQuerySort(throwRestrictedRelations(auth), { schema }));
     }
-    return pipeAsync(...transforms)(sort2);
+    await pipe(...transforms)(sort2);
   };
-  const validateFields = (fields2, schema) => {
+  const validateFields = async (fields2, schema) => {
     if (!schema) {
       throw new Error("Missing schema in validateFields");
     }
     const transforms = [defaultValidateFields(schema)];
-    return pipeAsync(...transforms)(fields2);
+    await pipe(...transforms)(fields2);
+  };
+  const validatePopulate = async (populate2, schema, { auth } = {}) => {
+    if (!schema) {
+      throw new Error("Missing schema in sanitizePopulate");
+    }
+    const transforms = [defaultValidatePopulate(schema)];
+    if (auth) {
+      transforms.push(traverseQueryPopulate(throwRestrictedRelations(auth), { schema }));
+    }
+    await pipe(...transforms)(populate2);
   };
   return {
     input: validateInput,
     query: validateQuery,
     filters: validateFilters,
     sort: validateSort,
-    fields: validateFields
+    fields: validateFields,
+    populate: validatePopulate
   };
 };
 const contentAPI = createContentAPIValidators();
@@ -2510,7 +2078,7 @@ const index = {
   validators,
   visitors
 };
-const { PUBLISHED_AT_ATTRIBUTE } = constants$1;
+const { ID_ATTRIBUTE, DOC_ID_ATTRIBUTE, PUBLISHED_AT_ATTRIBUTE } = constants$1;
 class InvalidOrderError extends Error {
   constructor() {
     super();
@@ -2524,7 +2092,7 @@ class InvalidSortError extends Error {
   }
 }
 function validateOrder(order) {
-  if (!isString$1(order) || !["asc", "desc"].includes(order.toLocaleLowerCase())) {
+  if (!isString(order) || !["asc", "desc"].includes(order.toLocaleLowerCase())) {
     throw new InvalidOrderError();
   }
 }
@@ -2534,8 +2102,8 @@ const convertCountQueryParams = (countQuery) => {
 const convertOrderingQueryParams = (ordering) => {
   return ordering;
 };
-const isPlainObject = (value2) => _$1.isPlainObject(value2);
-const isStringArray = (value2) => isArray(value2) && value2.every(isString$1);
+const isPlainObject = (value) => _$1.isPlainObject(value);
+const isStringArray = (value) => isArray(value) && value.every(isString);
 const convertSortQueryParams = (sortQuery) => {
   if (typeof sortQuery === "string") {
     return convertStringSortQueryParam(sortQuery);
@@ -2552,13 +2120,13 @@ const convertSortQueryParams = (sortQuery) => {
   throw new InvalidSortError();
 };
 const convertStringSortQueryParam = (sortQuery) => {
-  return sortQuery.split(",").map((value2) => convertSingleSortQueryParam(value2));
+  return sortQuery.split(",").map((value) => convertSingleSortQueryParam(value));
 };
 const convertSingleSortQueryParam = (sortQuery) => {
   if (!sortQuery) {
     return {};
   }
-  if (!isString$1(sortQuery)) {
+  if (!isString(sortQuery)) {
     throw new Error("Invalid sort query");
   }
   const [field, order = "asc"] = sortQuery.split(":");
@@ -2638,15 +2206,15 @@ const convertPopulateQueryParams = (populate2, schema, depth = 0) => {
     return true;
   }
   if (typeof populate2 === "string") {
-    return populate2.split(",").map((value2) => _$1.trim(value2));
+    return populate2.split(",").map((value) => _$1.trim(value));
   }
   if (Array.isArray(populate2)) {
     return _$1.uniq(
-      populate2.flatMap((value2) => {
-        if (typeof value2 !== "string") {
+      populate2.flatMap((value) => {
+        if (typeof value !== "string") {
           throw new InvalidPopulateError();
         }
-        return value2.split(",").map((value22) => _$1.trim(value22));
+        return value.split(",").map((value2) => _$1.trim(value2));
       })
     );
   }
@@ -2655,25 +2223,30 @@ const convertPopulateQueryParams = (populate2, schema, depth = 0) => {
   }
   throw new InvalidPopulateError();
 };
+const hasFragmentPopulateDefined = (populate2) => {
+  return typeof populate2 === "object" && "on" in populate2 && !isNil(populate2.on);
+};
 const convertPopulateObject = (populate2, schema) => {
   if (!schema) {
     return {};
   }
   const { attributes } = schema;
-  return Object.entries(populate2).reduce((acc2, [key2, subPopulate]) => {
-    const attribute = attributes[key2];
+  return Object.entries(populate2).reduce((acc, [key, subPopulate]) => {
+    if (_$1.isBoolean(subPopulate)) {
+      return { ...acc, [key]: subPopulate };
+    }
+    const attribute = attributes[key];
     if (!attribute) {
-      return acc2;
+      return acc;
     }
     const isAllowedAttributeForFragmentPopulate = isDynamicZoneAttribute(attribute) || isMorphToRelationalAttribute(attribute);
-    const hasFragmentPopulateDefined = typeof subPopulate === "object" && "on" in subPopulate && !isNil(subPopulate.on);
-    if (isAllowedAttributeForFragmentPopulate && hasFragmentPopulateDefined) {
+    if (isAllowedAttributeForFragmentPopulate && hasFragmentPopulateDefined(subPopulate)) {
       return {
-        ...acc2,
-        [key2]: {
+        ...acc,
+        [key]: {
           on: Object.entries(subPopulate.on).reduce(
-            (acc22, [type, typeSubPopulate]) => ({
-              ...acc22,
+            (acc2, [type, typeSubPopulate]) => ({
+              ...acc2,
               [type]: convertNestedPopulate(typeSubPopulate, strapi.getModel(type))
             }),
             {}
@@ -2684,15 +2257,15 @@ const convertPopulateObject = (populate2, schema) => {
     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 (isEmpty(populates)) {
-        return acc2;
+        return acc;
       }
       return {
-        ...acc2,
-        [key2]: mergeAll(populates)
+        ...acc,
+        [key]: mergeAll(populates)
       };
     }
     if (isMorphToRelationalAttribute(attribute)) {
-      return { ...acc2, [key2]: convertNestedPopulate(subPopulate, void 0) };
+      return { ...acc, [key]: convertNestedPopulate(subPopulate, void 0) };
     }
     let targetSchemaUID;
     if (attribute.type === "relation") {
@@ -2702,19 +2275,19 @@ const convertPopulateObject = (populate2, schema) => {
     } else if (attribute.type === "media") {
       targetSchemaUID = "plugin::upload.file";
     } else {
-      return acc2;
+      return acc;
     }
     const targetSchema = strapi.getModel(targetSchemaUID);
     if (!targetSchema) {
-      return acc2;
+      return acc;
     }
     const populateObject = convertNestedPopulate(subPopulate, targetSchema);
     if (!populateObject) {
-      return acc2;
+      return acc;
     }
     return {
-      ...acc2,
-      [key2]: populateObject
+      ...acc,
+      [key]: populateObject
     };
   }, {});
 };
@@ -2748,282 +2321,707 @@ const convertNestedPopulate = (subPopulate, schema) => {
   if (ordering) {
     query.ordering = convertOrderingQueryParams(ordering);
   }
-  validatePaginationParams(page, pageSize, start, limit);
-  if (!isNil(page)) {
-    query.page = convertPageQueryParams(page);
+  validatePaginationParams(page, pageSize, start, limit);
+  if (!isNil(page)) {
+    query.page = convertPageQueryParams(page);
+  }
+  if (!isNil(pageSize)) {
+    query.pageSize = convertPageSizeQueryParams(pageSize, page);
+  }
+  if (!isNil(start)) {
+    query.offset = convertStartQueryParams(start);
+  }
+  if (!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) => _$1.trim(value));
+    return _$1.uniq([ID_ATTRIBUTE, DOC_ID_ATTRIBUTE, ...fieldsValues]);
+  }
+  if (isStringArray(fields2)) {
+    const fieldsValues = fields2.flatMap((value) => convertFieldsQueryParams(value, depth + 1)).filter((v) => !isNil(v));
+    return _$1.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 (!isObject(filters2)) {
+    throw new Error("The filters parameter must be an object or an array");
+  }
+  const filtersCopy = 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) || !isEmpty(filter));
+  }
+  if (!isPlainObject(filters2)) {
+    return filters2;
+  }
+  const removeOperator = (operator) => delete filters2[operator];
+  for (const [key, value] of Object.entries(filters2)) {
+    const attribute = 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 (isObject(value)) {
+      filters2[key] = convertAndSanitizeFilters(value, schema);
+    }
+    if (isPlainObject(filters2[key]) && 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 (!isNil(status)) {
+    convertStatusParams(status, query);
+  }
+  if (!isNil(_q)) {
+    query._q = _q;
+  }
+  if (!isNil(sort2)) {
+    query.orderBy = convertSortQueryParams(sort2);
+  }
+  if (!isNil(filters2)) {
+    query.where = convertFiltersQueryParams(filters2, schema);
+  }
+  if (!isNil(fields2)) {
+    query.select = convertFieldsQueryParams(fields2);
+  }
+  if (!isNil(populate2)) {
+    query.populate = convertPopulateQueryParams(populate2, schema);
+  }
+  validatePaginationParams(page, pageSize, start, limit);
+  if (!isNil(page)) {
+    query.page = convertPageQueryParams(page);
+  }
+  if (!isNil(pageSize)) {
+    query.pageSize = convertPageSizeQueryParams(pageSize, page);
+  }
+  if (!isNil(start)) {
+    query.offset = convertStartQueryParams(start);
+  }
+  if (!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 = machineIdSync();
+    return deviceId;
+  } catch (error) {
+    const deviceId = 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 = defaults(defaultValidationParam, options);
+    const result = await schema.validate(body, optionsWithDefaults);
+    return result;
+  } catch (e) {
+    if (e instanceof yup$1.ValidationError) {
+      handleYupError(e, errorMessage);
+    }
+    throw e;
+  }
+};
+const validateYupSchemaSync = (schema, options = {}) => (body, errorMessage) => {
+  try {
+    const optionsWithDefaults = defaults(defaultValidationParam, options);
+    return schema.validateSync(body, optionsWithDefaults);
+  } catch (e) {
+    if (e instanceof yup$1.ValidationError) {
+      handleYupError(e, errorMessage);
+    }
+    throw e;
+  }
+};
+const STRAPI_DEFAULTS = {
+  offset: {
+    start: 0,
+    limit: 10
+  },
+  page: {
+    page: 1,
+    pageSize: 10
+  }
+};
+const paginationAttributes = ["start", "limit", "page", "pageSize"];
+const withMaxLimit = (limit, maxLimit = -1) => {
+  if (maxLimit === -1 || limit < maxLimit) {
+    return limit;
+  }
+  return maxLimit;
+};
+const ensureMinValues = ({ start, limit }) => ({
+  start: Math.max(start, 0),
+  limit: limit === -1 ? limit : Math.max(limit, 1)
+});
+const ensureMaxValues = (maxLimit = -1) => ({ start, limit }) => ({
+  start,
+  limit: withMaxLimit(limit, maxLimit)
+});
+const withNoLimit = (pagination2, maxLimit = -1) => ({
+  ...pagination2,
+  limit: pagination2.limit === -1 ? maxLimit : pagination2.limit
+});
+const withDefaultPagination = (args, { defaults: defaults2 = {}, maxLimit = -1 } = {}) => {
+  const defaultValues = merge(STRAPI_DEFAULTS, defaults2);
+  const usePagePagination = !isNil(args.page) || !isNil(args.pageSize);
+  const useOffsetPagination = !isNil(args.start) || !isNil(args.limit);
+  const ensureValidValues = pipe$1(ensureMinValues, ensureMaxValues(maxLimit));
+  if (!usePagePagination && !useOffsetPagination) {
+    return merge(args, ensureValidValues(defaultValues.offset));
+  }
+  if (usePagePagination && useOffsetPagination) {
+    throw new PaginationError("Cannot use both page & offset pagination in the same query");
   }
-  if (!isNil(pageSize)) {
-    query.pageSize = convertPageSizeQueryParams(pageSize, page);
+  const pagination2 = {
+    start: 0,
+    limit: 0
+  };
+  if (useOffsetPagination) {
+    const { start, limit } = merge(defaultValues.offset, args);
+    Object.assign(pagination2, { start, limit });
   }
-  if (!isNil(start)) {
-    query.offset = convertStartQueryParams(start);
+  if (usePagePagination) {
+    const { page, pageSize } = merge(defaultValues.page, {
+      ...args,
+      pageSize: Math.max(1, args.pageSize ?? 0)
+    });
+    Object.assign(pagination2, {
+      start: (page - 1) * pageSize,
+      limit: pageSize
+    });
   }
-  if (!isNil(limit)) {
-    query.limit = convertLimitQueryParams(limit);
+  Object.assign(pagination2, withNoLimit(pagination2, maxLimit));
+  const replacePaginationAttributes = pipe$1(
+    // Remove pagination attributes
+    omit(paginationAttributes),
+    // Merge the object with the new pagination + ensure minimum & maximum values
+    merge(ensureValidValues(pagination2))
+  );
+  return replacePaginationAttributes(args);
+};
+const pagination = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  withDefaultPagination
+}, Symbol.toStringTag, { value: "Module" }));
+const SUPPORTED_PACKAGE_MANAGERS = ["npm", "yarn"];
+const DEFAULT_PACKAGE_MANAGER = "npm";
+const getPreferred = async (pkgPath) => {
+  const pm = await preferredPM(pkgPath);
+  const hasPackageManager = pm !== void 0;
+  if (!hasPackageManager) {
+    throw new Error(`Couldn't find a package manager in your project.`);
+  }
+  const isPackageManagerSupported = SUPPORTED_PACKAGE_MANAGERS.includes(pm.name);
+  if (!isPackageManagerSupported) {
+    process.emitWarning(
+      `We detected your package manager (${pm.name} v${pm.version}), but it's not officially supported by Strapi yet. Defaulting to npm instead.`
+    );
+    return DEFAULT_PACKAGE_MANAGER;
   }
-  convertPublicationStateParams(schema, subPopulate, query);
-  return query;
+  return pm.name;
 };
-const convertFieldsQueryParams = (fields2, depth = 0) => {
-  if (depth === 0 && fields2 === "*") {
-    return void 0;
+const installDependencies = (path, packageManager2, options = {}) => {
+  return execa(packageManager2, ["install"], { ...options, cwd: path, stdin: "ignore" });
+};
+const packageManager = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getPreferred,
+  installDependencies
+}, Symbol.toStringTag, { value: "Module" }));
+const createStrictInterpolationRegExp = (allowedVariableNames, flags) => {
+  const oneOfVariables = allowedVariableNames.join("|");
+  return new RegExp(`<%=\\s*(${oneOfVariables})\\s*%>`, flags);
+};
+const createLooseInterpolationRegExp = (flags) => new RegExp(/<%=([\s\S]+?)%>/, flags);
+const template = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createLooseInterpolationRegExp,
+  createStrictInterpolationRegExp
+}, Symbol.toStringTag, { value: "Module" }));
+const kbytesToBytes = (kbytes) => kbytes * 1e3;
+const bytesToKbytes = (bytes) => Math.round(bytes / 1e3 * 100) / 100;
+const bytesToHumanReadable = (bytes) => {
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  if (bytes === 0)
+    return "0 Bytes";
+  const i = parseInt(`${Math.floor(Math.log(bytes) / Math.log(1e3))}`, 10);
+  return `${Math.round(bytes / 1e3 ** i)} ${sizes[i]}`;
+};
+const streamToBuffer = (stream) => new Promise((resolve, reject) => {
+  const chunks = [];
+  stream.on("data", (chunk) => {
+    chunks.push(chunk);
+  });
+  stream.on("end", () => {
+    resolve(Buffer.concat(chunks));
+  });
+  stream.on("error", reject);
+});
+const getStreamSize = (stream) => new Promise((resolve, reject) => {
+  let size = 0;
+  stream.on("data", (chunk) => {
+    size += Buffer.byteLength(chunk);
+  });
+  stream.on("close", () => resolve(size));
+  stream.on("error", reject);
+  stream.resume();
+});
+function writableDiscardStream(options) {
+  return new Writable({
+    ...options,
+    write(chunk, encding, callback) {
+      setImmediate(callback);
+    }
+  });
+}
+const file = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  bytesToHumanReadable,
+  bytesToKbytes,
+  getStreamSize,
+  kbytesToBytes,
+  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: {} };
   }
-  if (typeof fields2 === "string") {
-    const fieldsValues = fields2.split(",").map((value2) => _$1.trim(value2));
-    return _$1.uniq(["id", ...fieldsValues]);
+  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 (isStringArray(fields2)) {
-    const fieldsValues = fields2.flatMap((value2) => convertFieldsQueryParams(value2, depth + 1)).filter((v) => !isNil(v));
-    return _$1.uniq(["id", ...fieldsValues]);
+  if (apiName) {
+    return strapi.policy(`${API_PREFIX}${apiName}.${policyName}`);
   }
-  throw new Error("Invalid fields parameter. Expected a string or an array of strings");
 };
-const isValidSchemaAttribute = (key2, schema) => {
-  if (key2 === "id") {
-    return true;
+const globalPolicy = ({ method, endpoint, controller, action, plugin }) => {
+  return async (ctx, next) => {
+    ctx.request.route = {
+      endpoint: `${method} ${endpoint}`,
+      controller: _$1.toLower(controller),
+      action: _$1.toLower(action),
+      verb: _$1.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;
   }
-  if (!schema) {
-    return false;
+  const localPolicy = searchLocalPolicy(name, { pluginName, apiName });
+  if (localPolicy !== void 0) {
+    return localPolicy;
   }
-  return Object.keys(schema.attributes).includes(key2);
+  throw new Error(`Could not find policy "${name}"`);
 };
-const convertFiltersQueryParams = (filters2, schema) => {
-  if (!isObject(filters2)) {
-    throw new Error("The filters parameter must be an object or an array");
+const getPolicy = (policyConfig, policyContext) => {
+  const { pluginName, apiName } = policyContext ?? {};
+  if (typeof policyConfig === "function") {
+    return policyConfig;
   }
-  const filtersCopy = 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) || !isEmpty(filter));
+  const { policyName, config } = parsePolicy(policyConfig);
+  const policy2 = findPolicy(policyName, { pluginName, apiName });
+  if (typeof policy2 === "function") {
+    return policy2;
   }
-  if (!isPlainObject(filters2)) {
-    return filters2;
+  if (policy2.validator) {
+    policy2.validator(config);
   }
-  const removeOperator = (operator) => delete filters2[operator];
-  for (const [key2, value2] of Object.entries(filters2)) {
-    const attribute = get(key2, schema?.attributes);
-    const validKey = isOperator(key2) || isValidSchemaAttribute(key2, schema);
-    if (!validKey) {
-      removeOperator(key2);
-    } else if (attribute) {
-      if (attribute.type === "relation") {
-        filters2[key2] = convertAndSanitizeFilters(value2, strapi.getModel(attribute.target));
-      } else if (attribute.type === "component") {
-        filters2[key2] = convertAndSanitizeFilters(value2, strapi.getModel(attribute.component));
-      } else if (attribute.type === "media") {
-        filters2[key2] = convertAndSanitizeFilters(value2, strapi.getModel("plugin::upload.file"));
-      } else if (attribute.type === "dynamiczone") {
-        removeOperator(key2);
-      } else if (attribute.type === "password") {
-        removeOperator(key2);
-      } else {
-        filters2[key2] = convertAndSanitizeFilters(value2, schema);
+  return policy2.handler;
+};
+const createPolicy = (options) => {
+  const { name = "unnamed", validator, handler } = options;
+  const wrappedValidator = (config) => {
+    if (validator) {
+      try {
+        validator(config);
+      } catch (e) {
+        throw new Error(`Invalid config passed to "${name}" policy.`);
       }
-    } else if (["$null", "$notNull"].includes(key2)) {
-      filters2[key2] = parseType({ type: "boolean", value: filters2[key2], forceCast: true });
-    } else if (isObject(value2)) {
-      filters2[key2] = convertAndSanitizeFilters(value2, schema);
     }
-    if (isPlainObject(filters2[key2]) && isEmpty(filters2[key2])) {
-      removeOperator(key2);
-    }
-  }
-  return filters2;
+  };
+  return {
+    name,
+    validator: wrappedValidator,
+    handler
+  };
 };
-const convertPublicationStateParams = (schema, params = {}, query = {}) => {
-  if (!schema) {
-    return;
-  }
-  const { publicationState } = params;
-  if (!_$1.isNil(publicationState)) {
-    if (!constants$1.DP_PUB_STATES.includes(publicationState)) {
-      throw new Error(
-        `Invalid publicationState. Expected one of 'preview','live' received: ${publicationState}.`
-      );
-    }
-    query.filters = ({ meta }) => {
-      if (publicationState === "live" && has(PUBLISHED_AT_ATTRIBUTE, meta.attributes)) {
-        return { [PUBLISHED_AT_ATTRIBUTE]: { $notNull: true } };
+const createPolicyContext = (type, ctx) => {
+  return Object.assign(
+    {
+      is: eq(type),
+      get type() {
+        return type;
       }
-    };
-  }
+    },
+    ctx
+  );
+};
+const policy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createPolicy,
+  createPolicyContext,
+  get: getPolicy,
+  globalPolicy,
+  resolve: resolvePolicies
+}, Symbol.toStringTag, { value: "Module" }));
+const nameToSlug = (name, options = { separator: "-" }) => slugify(name, options);
+const nameToCollectionName = (name) => slugify(name, { separator: "_" });
+const toRegressedEnumValue = (value) => slugify(value, {
+  decamelize: false,
+  lowercase: false,
+  separator: "_"
+});
+const getCommonPath = (...paths) => {
+  const [segments, ...otherSegments] = paths.map((it) => _$1.split(it, "/"));
+  return _$1.join(
+    _$1.takeWhile(segments, (str, index2) => otherSegments.every((it) => it[index2] === str)),
+    "/"
+  );
+};
+const isEqual = (a, b) => String(a) === String(b);
+const isCamelCase = (value) => /^[a-z][a-zA-Z0-9]+$/.test(value);
+const isKebabCase = (value) => /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/.test(value);
+const startsWithANumber = (value) => /^[0-9]/.test(value);
+const joinBy = (joint, ...args) => {
+  const trim2 = trimChars(joint);
+  const trimEnd = trimCharsEnd(joint);
+  const trimStart = trimCharsStart(joint);
+  return args.reduce((url, path, index2) => {
+    if (args.length === 1)
+      return path;
+    if (index2 === 0)
+      return trimEnd(path);
+    if (index2 === args.length - 1)
+      return url + joint + trimStart(path);
+    return url + joint + trim2(path);
+  }, "");
+};
+const toKebabCase = (value) => kebabCase(value);
+const strings = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getCommonPath,
+  isCamelCase,
+  isEqual,
+  isKebabCase,
+  joinBy,
+  nameToCollectionName,
+  nameToSlug,
+  startsWithANumber,
+  toKebabCase,
+  toRegressedEnumValue
+}, Symbol.toStringTag, { value: "Module" }));
+const castIncludes = (arr, val, cast) => arr.map((val2) => cast(val2)).includes(cast(val));
+const includesString = (arr, val) => castIncludes(arr, val, String);
+const arrays = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  includesString
+}, Symbol.toStringTag, { value: "Module" }));
+const keysDeep = (obj, path = []) => !_$1.isObject(obj) ? [path.join(".")] : _$1.reduce(
+  obj,
+  (acc, next, key) => _$1.concat(acc, keysDeep(next, [...path, key])),
+  []
+);
+const objects = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  keysDeep
+}, Symbol.toStringTag, { value: "Module" }));
+const timestampCode = (date) => {
+  const referDate = date ?? /* @__PURE__ */ new Date();
+  return referDate.getTime().toString(36);
 };
-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 } = params;
-  if (!isNil(_q)) {
-    query._q = _q;
-  }
-  if (!isNil(sort2)) {
-    query.orderBy = convertSortQueryParams(sort2);
-  }
-  if (!isNil(filters2)) {
-    query.where = convertFiltersQueryParams(filters2, schema);
+const dates = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  timestampCode
+}, Symbol.toStringTag, { value: "Module" }));
+const { toString } = Object.prototype;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+const symbolToString = typeof Symbol !== "undefined" ? Symbol.prototype.toString : () => "";
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+function printNumber(val) {
+  if (val != +val)
+    return "NaN";
+  const isNegativeZero = val === 0 && 1 / val < 0;
+  return isNegativeZero ? "-0" : `${val}`;
+}
+function printSimpleValue(val, quoteStrings = false) {
+  if (val == null || val === true || val === false)
+    return `${val}`;
+  if (typeof val === "number")
+    return printNumber(val);
+  if (typeof val === "string")
+    return quoteStrings ? `"${val}"` : val;
+  if (typeof val === "function")
+    return `[Function ${val.name || "anonymous"}]`;
+  if (typeof val === "symbol")
+    return symbolToString.call(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+  const tag = toString.call(val).slice(8, -1);
+  if (tag === "Date") {
+    const v = val;
+    return Number.isNaN(v.getTime()) ? `${v}` : v.toISOString();
   }
-  if (!isNil(fields2)) {
-    query.select = convertFieldsQueryParams(fields2);
+  if (tag === "Error" || val instanceof Error)
+    return `[${errorToString.call(val)}]`;
+  if (tag === "RegExp")
+    return regExpToString.call(val);
+  return null;
+}
+function printValue(value, quoteStrings) {
+  const result = printSimpleValue(value, quoteStrings);
+  if (result !== null)
+    return result;
+  return JSON.stringify(
+    value,
+    function replacer(key, value2) {
+      const result2 = printSimpleValue(this[key], quoteStrings);
+      if (result2 !== null)
+        return result2;
+      return value2;
+    },
+    2
+  );
+}
+const strapiID = () => new StrapiIDSchema();
+const isNotNilTest = (value) => !_$1.isNil(value);
+const isNotNullTest = (value) => !_$1.isNull(value);
+yup$1.addMethod(yup$1.mixed, "notNil", function isNotNill(msg = "${path} must be defined.") {
+  return this.test("defined", msg, isNotNilTest);
+});
+yup$1.addMethod(yup$1.mixed, "notNull", function isNotNull(msg = "${path} cannot be null.") {
+  return this.test("defined", msg, isNotNullTest);
+});
+yup$1.addMethod(yup$1.mixed, "isFunction", function isFunction(message = "${path} is not a function") {
+  return this.test(
+    "is a function",
+    message,
+    (value) => _$1.isUndefined(value) || _$1.isFunction(value)
+  );
+});
+yup$1.addMethod(
+  yup$1.string,
+  "isCamelCase",
+  function isCamelCase$1(message = "${path} is not in camel case (anExampleOfCamelCase)") {
+    return this.test(
+      "is in camelCase",
+      message,
+      (value) => value ? isCamelCase(value) : true
+    );
   }
-  if (!isNil(populate2)) {
-    query.populate = convertPopulateQueryParams(populate2, schema);
+);
+yup$1.addMethod(
+  yup$1.string,
+  "isKebabCase",
+  function isKebabCase$1(message = "${path} is not in kebab case (an-example-of-kebab-case)") {
+    return this.test(
+      "is in kebab-case",
+      message,
+      (value) => value ? isKebabCase(value) : true
+    );
   }
-  validatePaginationParams(page, pageSize, start, limit);
-  if (!isNil(page)) {
-    query.page = convertPageQueryParams(page);
+);
+yup$1.addMethod(
+  yup$1.object,
+  "onlyContainsFunctions",
+  function onlyContainsFunctions(message = "${path} contains values that are not functions") {
+    return this.test(
+      "only contains functions",
+      message,
+      (value) => _$1.isUndefined(value) || value && Object.values(value).every(_$1.isFunction)
+    );
   }
-  if (!isNil(pageSize)) {
-    query.pageSize = convertPageSizeQueryParams(pageSize, page);
+);
+yup$1.addMethod(
+  yup$1.array,
+  "uniqueProperty",
+  function uniqueProperty(propertyName, message) {
+    return this.test("unique", message, function unique(list) {
+      const errors2 = [];
+      list?.forEach((element, index2) => {
+        const sameElements = list.filter(
+          (e) => get(propertyName, e) === get(propertyName, element)
+        );
+        if (sameElements.length > 1) {
+          errors2.push(
+            this.createError({
+              path: `${this.path}[${index2}].${propertyName}`,
+              message
+            })
+          );
+        }
+      });
+      if (errors2.length) {
+        throw new yup$1.ValidationError(errors2);
+      }
+      return true;
+    });
   }
-  if (!isNil(start)) {
-    query.offset = convertStartQueryParams(start);
+);
+class StrapiIDSchema extends yup$1.MixedSchema {
+  constructor() {
+    super({ type: "strapiID" });
   }
-  if (!isNil(limit)) {
-    query.limit = convertLimitQueryParams(limit);
+  _typeCheck(value) {
+    return typeof value === "string" || isNumber(value) && isInteger(value) && value >= 0;
   }
-  convertPublicationStateParams(schema, params, query);
-  return query;
-};
-const convertQueryParams = {
-  convertSortQueryParams,
-  convertStartQueryParams,
-  convertLimitQueryParams,
-  convertPopulateQueryParams,
-  convertFiltersQueryParams,
-  convertFieldsQueryParams,
-  convertPublicationStateParams,
-  transformParamsToQuery
-};
-function importDefault(modName) {
-  const mod = require(modName);
-  return mod && mod.__esModule ? mod.default : mod;
 }
-const createStrictInterpolationRegExp = (allowedVariableNames, flags) => {
-  const oneOfVariables = allowedVariableNames.join("|");
-  return new RegExp(`<%=\\s*(${oneOfVariables})\\s*%>`, flags);
-};
-const createLooseInterpolationRegExp = (flags) => new RegExp(/<%=([\s\S]+?)%>/, flags);
-const template = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  createLooseInterpolationRegExp,
-  createStrictInterpolationRegExp
-}, Symbol.toStringTag, { value: "Module" }));
-const kbytesToBytes = (kbytes) => kbytes * 1e3;
-const bytesToKbytes = (bytes) => Math.round(bytes / 1e3 * 100) / 100;
-const bytesToHumanReadable = (bytes) => {
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
-  if (bytes === 0)
-    return "0 Bytes";
-  const i = parseInt(`${Math.floor(Math.log(bytes) / Math.log(1e3))}`, 10);
-  return `${Math.round(bytes / 1e3 ** i)} ${sizes[i]}`;
-};
-const streamToBuffer = (stream) => new Promise((resolve, reject) => {
-  const chunks = [];
-  stream.on("data", (chunk) => {
-    chunks.push(chunk);
-  });
-  stream.on("end", () => {
-    resolve(Buffer.concat(chunks));
-  });
-  stream.on("error", reject);
-});
-const getStreamSize = (stream) => new Promise((resolve, reject) => {
-  let size = 0;
-  stream.on("data", (chunk) => {
-    size += Buffer.byteLength(chunk);
-  });
-  stream.on("close", () => resolve(size));
-  stream.on("error", reject);
-  stream.resume();
-});
-function writableDiscardStream(options) {
-  return new Writable({
-    ...options,
-    write(chunk, encding, callback) {
-      setImmediate(callback);
+yup$1.setLocale({
+  mixed: {
+    notType(options) {
+      const { path, type, value, originalValue } = options;
+      const isCast = originalValue != null && originalValue !== value;
+      const msg = `${path} must be a \`${type}\` type, but the final value was: \`${printValue(value, true)}\`${isCast ? ` (cast from the value \`${printValue(originalValue, true)}\`).` : "."}`;
+      return msg;
     }
-  });
-}
-const file = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  bytesToHumanReadable,
-  bytesToKbytes,
-  getStreamSize,
-  kbytesToBytes,
-  streamToBuffer,
-  writableDiscardStream
-}, Symbol.toStringTag, { value: "Module" }));
-const webhookEvents = {
-  ENTRY_CREATE: "entry.create",
-  ENTRY_UPDATE: "entry.update",
-  ENTRY_DELETE: "entry.delete",
-  ENTRY_PUBLISH: "entry.publish",
-  ENTRY_UNPUBLISH: "entry.unpublish",
-  MEDIA_CREATE: "media.create",
-  MEDIA_UPDATE: "media.update",
-  MEDIA_DELETE: "media.delete"
-};
-const deprecatedWebhookEvents = new Proxy(webhookEvents, {
-  get(target, prop) {
-    console.warn(
-      "[deprecated] @strapi/utils/webhook will no longer exist in the next major release of Strapi. Instead, the webhookEvents object can be retrieved from strapi.webhookStore.allowedEvents"
-    );
-    return target[prop];
   }
 });
-const webhook = {
-  webhookEvents: deprecatedWebhookEvents
+const yup = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  StrapiIDSchema,
+  strapiID
+}, [yup$1]);
+const MANY_RELATIONS = ["oneToMany", "manyToMany"];
+const getRelationalFields = (contentType) => {
+  return Object.keys(contentType.attributes).filter((attributeName) => {
+    return contentType.attributes[attributeName].type === "relation";
+  });
+};
+const isOneToAny = (attribute) => isRelationalAttribute(attribute) && ["oneToOne", "oneToMany"].includes(attribute.relation);
+const isManyToAny = (attribute) => isRelationalAttribute(attribute) && ["manyToMany", "manyToOne"].includes(attribute.relation);
+const isAnyToOne = (attribute) => isRelationalAttribute(attribute) && ["oneToOne", "manyToOne"].includes(attribute.relation);
+const isAnyToMany = (attribute) => isRelationalAttribute(attribute) && ["oneToMany", "manyToMany"].includes(attribute.relation);
+const constants = {
+  MANY_RELATIONS
 };
+const relations = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  constants,
+  getRelationalFields,
+  isAnyToMany,
+  isAnyToOne,
+  isManyToAny,
+  isOneToAny
+}, Symbol.toStringTag, { value: "Module" }));
 export {
+  arrays,
+  async,
   contentTypes,
   convertQueryParams,
+  dates,
   env,
   errors,
-  escapeQuery,
   file,
-  forEachAsync,
-  generateTimestampCode,
-  getAbsoluteAdminUrl,
-  getAbsoluteServerUrl,
-  getCommonBeginning,
-  getConfigUrls,
-  handleYupError,
   hooks,
   importDefault,
-  isCamelCase,
-  isKebabCase,
   isOperator,
   isOperatorOfType,
-  joinBy,
-  keysDeep,
-  mapAsync,
-  nameToCollectionName,
-  nameToSlug,
+  machineId as machineID,
+  objects,
+  packageManager,
   pagination,
-  parseMultipartData,
   parseType,
-  pipeAsync,
   policy,
   providerFactory,
-  reduceAsync,
   relations,
-  removeUndefined,
   index$1 as sanitize,
   setCreatorFields,
-  startsWithANumber,
-  stringEquals,
-  stringIncludes,
+  strings,
   template,
-  templateConfiguration,
-  toKebabCase,
-  toRegressedEnumValue,
   index$2 as traverse,
   traverseEntity$1 as traverseEntity,
   index as validate,
   validateYupSchema,
   validateYupSchemaSync,
-  webhook,
   yup
 };
 //# sourceMappingURL=index.mjs.map