@strapi/utils 5.12.1 → 5.12.2

package/dist/index.js

@@ -1,4370 +1,66 @@
 'use strict';
 
-var _ = require('lodash');
-var dates$1 = require('date-fns');
-var fp = require('lodash/fp');
-var crypto = require('crypto');
-var nodeMachineId = require('node-machine-id');
-var yup$1 = require('yup');
-var httpErrors = require('http-errors');
-var pMap = require('p-map');
-var execa = require('execa');
-var preferredPM = require('preferred-pm');
-var node_stream = require('node:stream');
-var slugify = require('@sindresorhus/slugify');
-var zod = require('zod');
+var parseType = require('./parse-type.js');
+var envHelper = require('./env-helper.js');
+var setCreatorFields = require('./set-creator-fields.js');
+var providerFactory = require('./provider-factory.js');
+var traverseEntity = require('./traverse-entity.js');
+var importDefault = require('./import-default.js');
+var machineId = require('./machine-id.js');
+var validators = require('./validators.js');
+var operators = require('./operators.js');
+var convertQueryParams = require('./convert-query-params.js');
+var index = require('./sanitize/index.js');
+var index$1 = require('./validate/index.js');
+var pagination = require('./pagination.js');
+var packageManager = require('./package-manager.js');
+var index$2 = require('./traverse/index.js');
+var template = require('./template.js');
+var file = require('./file.js');
+var async = require('./async.js');
+var policy = require('./policy.js');
+var yup = require('./yup.js');
+var errors = require('./errors.js');
+var contentTypes = require('./content-types.js');
+var relations = require('./relations.js');
+var hooks = require('./hooks.js');
+var zod = require('./zod.js');
+var strings = require('./primitives/strings.js');
+var arrays = require('./primitives/arrays.js');
+var objects = require('./primitives/objects.js');
+var dates = require('./primitives/dates.js');
 
-function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
 
-function _mergeNamespaces(n, m) {
-  m.forEach(function (e) {
-    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-      if (k !== 'default' && !(k in n)) {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  });
-  return Object.freeze(n);
-}
 
-var ___namespace = /*#__PURE__*/_interopNamespaceDefault(_);
-var dates__namespace = /*#__PURE__*/_interopNamespaceDefault(dates$1);
-var yup__namespace = /*#__PURE__*/_interopNamespaceDefault(yup$1);
-
-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__namespace.isDate(v);
-};
-const parseTime = (value)=>{
-    if (isDate(value)) {
-        return dates__namespace.format(value, 'HH:mm:ss.SSS');
-    }
-    if (typeof value !== 'string') {
-        throw new Error(`Expected a string, got a ${typeof value}`);
-    }
-    const result = value.match(timeRegex);
-    if (result === null) {
-        throw new Error('Invalid time format, expected HH:mm:ss.SSS');
-    }
-    const [, hours, minutes, seconds, fraction = '.000'] = result;
-    const fractionPart = ___namespace.padEnd(fraction.slice(1), 3, '0');
-    return `${hours}:${minutes}:${seconds}.${fractionPart}`;
-};
-const parseDate = (value)=>{
-    if (isDate(value)) {
-        return dates__namespace.format(value, 'yyyy-MM-dd');
-    }
-    if (typeof value !== 'string') {
-        throw new Error(`Expected a string, got a ${typeof value}`);
-    }
-    try {
-        const date = dates__namespace.parseISO(value);
-        if (dates__namespace.isValid(date)) return dates__namespace.format(date, 'yyyy-MM-dd');
-        throw new Error(`Invalid format, expected an ISO compatible date`);
-    } catch (error) {
-        throw new Error(`Invalid format, expected an ISO compatible date`);
-    }
-};
-const parseDateTimeOrTimestamp = (value)=>{
-    if (isDate(value)) {
-        return value;
-    }
-    if (typeof value !== 'string') {
-        throw new Error(`Expected a string, got a ${typeof value}`);
-    }
-    try {
-        const date = dates__namespace.parseISO(value);
-        if (dates__namespace.isValid(date)) return date;
-        const milliUnixDate = dates__namespace.parse(value, 'T', new Date());
-        if (dates__namespace.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 = (value, options)=>{
-    const { forceCast = false } = options;
-    if (typeof value === 'boolean') {
-        return value;
-    }
-    if (typeof value === 'string' || typeof value === 'number') {
-        if ([
-            'true',
-            't',
-            '1',
-            1
-        ].includes(value)) {
-            return true;
-        }
-        if ([
-            'false',
-            'f',
-            '0',
-            0
-        ].includes(value)) {
-            return false;
-        }
-    }
-    if (forceCast) {
-        return Boolean(value);
-    }
-    throw new Error('Invalid boolean input. Expected "t","1","true","false","0","f"');
-};
-/**
- * Cast basic values based on attribute type
- */ const parseType = (options)=>{
-    const { type, value, forceCast } = options;
-    switch(type){
-        case 'boolean':
-            return parseBoolean(value, {
-                forceCast
-            });
-        case 'integer':
-        case 'biginteger':
-        case 'float':
-        case 'decimal':
-            {
-                return ___namespace.toNumber(value);
-            }
-        case 'time':
-            {
-                return parseTime(value);
-            }
-        case 'date':
-            {
-                return parseDate(value);
-            }
-        case 'timestamp':
-        case 'datetime':
-            {
-                return parseDateTimeOrTimestamp(value);
-            }
-        default:
-            return value;
-    }
-};
-
-function envFn(key, defaultValue) {
-    return _.has(process.env, key) ? process.env[key] : defaultValue;
-}
-function getKey(key) {
-    return process.env[key] ?? '';
-}
-const utils = {
-    int (key, defaultValue) {
-        if (!_.has(process.env, key)) {
-            return defaultValue;
-        }
-        return parseInt(getKey(key), 10);
-    },
-    float (key, defaultValue) {
-        if (!_.has(process.env, key)) {
-            return defaultValue;
-        }
-        return parseFloat(getKey(key));
-    },
-    bool (key, defaultValue) {
-        if (!_.has(process.env, key)) {
-            return defaultValue;
-        }
-        return getKey(key) === 'true';
-    },
-    json (key, defaultValue) {
-        if (!_.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 (!_.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 _.trim(_.trim(v, ' '), '"');
-        });
-    },
-    date (key, defaultValue) {
-        if (!_.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 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 getTimestamps = (model)=>{
-    const attributes = [];
-    if (fp.has(CREATED_AT_ATTRIBUTE, model.attributes)) {
-        attributes.push(CREATED_AT_ATTRIBUTE);
-    }
-    if (fp.has(UPDATED_AT_ATTRIBUTE, model.attributes)) {
-        attributes.push(UPDATED_AT_ATTRIBUTE);
-    }
-    return attributes;
-};
-const getCreatorFields = (model)=>{
-    const attributes = [];
-    if (fp.has(CREATED_BY_ATTRIBUTE$3, model.attributes)) {
-        attributes.push(CREATED_BY_ATTRIBUTE$3);
-    }
-    if (fp.has(UPDATED_BY_ATTRIBUTE$3, model.attributes)) {
-        attributes.push(UPDATED_BY_ATTRIBUTE$3);
-    }
-    return attributes;
-};
-const getNonWritableAttributes = (model)=>{
-    if (!model) return [];
-    const nonWritableAttributes = _.reduce(model.attributes, (acc, attr, attrName)=>attr.writable === false ? acc.concat(attrName) : acc, []);
-    return _.uniq([
-        ID_ATTRIBUTE$4,
-        DOC_ID_ATTRIBUTE$4,
-        ...getTimestamps(model),
-        ...nonWritableAttributes
-    ]);
-};
-const getWritableAttributes = (model)=>{
-    if (!model) return [];
-    return _.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
-};
-const isWritableAttribute = (model, attributeName)=>{
-    return getWritableAttributes(model).includes(attributeName);
-};
-const getNonVisibleAttributes = (model)=>{
-    const nonVisibleAttributes = _.reduce(model.attributes, (acc, attr, attrName)=>attr.visible === false ? acc.concat(attrName) : acc, []);
-    return _.uniq([
-        ID_ATTRIBUTE$4,
-        DOC_ID_ATTRIBUTE$4,
-        ...getTimestamps(model),
-        ...nonVisibleAttributes
-    ]);
-};
-const getVisibleAttributes = (model)=>{
-    return _.difference(_.keys(model.attributes), getNonVisibleAttributes(model));
-};
-const isVisibleAttribute = (model, attributeName)=>{
-    return getVisibleAttributes(model).includes(attributeName);
-};
-const getOptions = (model)=>_.assign({
-        draftAndPublish: false
-    }, _.get(model, 'options', {}));
-const hasDraftAndPublish = (model)=>_.get(model, 'options.draftAndPublish', false) === true;
-const isDraft = (data, model)=>hasDraftAndPublish(model) && _.get(data, PUBLISHED_AT_ATTRIBUTE$1) === null;
-const isSchema = (data)=>{
-    return typeof data === 'object' && data !== null && 'modelType' in data && typeof data.modelType === 'string' && [
-        'component',
-        'contentType'
-    ].includes(data.modelType);
-};
-const isComponentSchema = (data)=>{
-    return isSchema(data) && data.modelType === 'component';
-};
-const isContentTypeSchema = (data)=>{
-    return isSchema(data) && data.modelType === 'contentType';
-};
-const isSingleType = ({ kind = COLLECTION_TYPE })=>kind === SINGLE_TYPE;
-const isCollectionType = ({ kind = COLLECTION_TYPE })=>kind === COLLECTION_TYPE;
-const isKind = (kind)=>(model)=>model.kind === kind;
-const getStoredPrivateAttributes = (model)=>fp.union(strapi?.config?.get('api.responses.privateAttributes', []) ?? [], fp.getOr([], 'options.privateAttributes', model));
-const getPrivateAttributes = (model)=>{
-    return _.union(getStoredPrivateAttributes(model), _.keys(_.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 attribute && ![
-        'media',
-        'component',
-        'relation',
-        'dynamiczone'
-    ].includes(attribute.type);
-};
-const getDoesAttributeRequireValidation = (attribute)=>{
-    return attribute.required || attribute.unique || Object.prototype.hasOwnProperty.call(attribute, 'max') || Object.prototype.hasOwnProperty.call(attribute, 'min') || Object.prototype.hasOwnProperty.call(attribute, 'maxLength') || Object.prototype.hasOwnProperty.call(attribute, 'minLength');
-};
-const isMediaAttribute = (attribute)=>attribute?.type === 'media';
-const isRelationalAttribute = (attribute)=>attribute?.type === 'relation';
-const HAS_RELATION_REORDERING = [
-    'manyToMany',
-    'manyToOne',
-    'oneToMany'
-];
-const hasRelationReordering = (attribute)=>isRelationalAttribute(attribute) && HAS_RELATION_REORDERING.includes(attribute.relation);
-const isComponentAttribute = (attribute)=>[
-        'component',
-        'dynamiczone'
-    ].includes(attribute?.type);
-const isDynamicZoneAttribute = (attribute)=>!!attribute && attribute.type === 'dynamiczone';
-const isMorphToRelationalAttribute = (attribute)=>{
-    return !!attribute && isRelationalAttribute(attribute) && attribute.relation?.startsWith?.('morphTo');
-};
-const getComponentAttributes = (schema)=>{
-    return _.reduce(schema.attributes, (acc, attr, attrName)=>{
-        if (isComponentAttribute(attr)) acc.push(attrName);
-        return acc;
-    }, []);
-};
-const getScalarAttributes = (schema)=>{
-    return _.reduce(schema.attributes, (acc, attr, attrName)=>{
-        if (isScalarAttribute(attr)) acc.push(attrName);
-        return acc;
-    }, []);
-};
-const getRelationalAttributes = (schema)=>{
-    return _.reduce(schema.attributes, (acc, attr, attrName)=>{
-        if (isRelationalAttribute(attr)) acc.push(attrName);
-        return acc;
-    }, []);
-};
-/**
- * Checks if an attribute is of type `type`
- * @param {object} attribute
- * @param {string} type
- */ const isTypedAttribute = (attribute, type)=>{
-    return _.has(attribute, 'type') && attribute.type === type;
-};
-/**
- *  Returns a route prefix for a contentType
- * @param {object} contentType
- * @returns {string}
- */ const getContentTypeRoutePrefix = (contentType)=>{
-    return isSingleType(contentType) ? _.kebabCase(contentType.info.singularName) : _.kebabCase(contentType.info.pluralName);
-};
-
-var contentTypes = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  constants: constants$1,
-  getComponentAttributes: getComponentAttributes,
-  getContentTypeRoutePrefix: getContentTypeRoutePrefix,
-  getCreatorFields: getCreatorFields,
-  getDoesAttributeRequireValidation: getDoesAttributeRequireValidation,
-  getNonVisibleAttributes: getNonVisibleAttributes,
-  getNonWritableAttributes: getNonWritableAttributes,
-  getOptions: getOptions,
-  getPrivateAttributes: getPrivateAttributes,
-  getRelationalAttributes: getRelationalAttributes,
-  getScalarAttributes: getScalarAttributes,
-  getTimestamps: getTimestamps,
-  getVisibleAttributes: getVisibleAttributes,
-  getWritableAttributes: getWritableAttributes,
-  hasDraftAndPublish: hasDraftAndPublish,
-  hasRelationReordering: hasRelationReordering,
-  isCollectionType: isCollectionType,
-  isComponentAttribute: isComponentAttribute,
-  isComponentSchema: isComponentSchema,
-  isContentTypeSchema: isContentTypeSchema,
-  isDraft: isDraft,
-  isDynamicZoneAttribute: isDynamicZoneAttribute,
-  isKind: isKind,
-  isMediaAttribute: isMediaAttribute,
-  isMorphToRelationalAttribute: isMorphToRelationalAttribute,
-  isPrivateAttribute: isPrivateAttribute,
-  isRelationalAttribute: isRelationalAttribute,
-  isScalarAttribute: isScalarAttribute,
-  isSchema: isSchema,
-  isSingleType: isSingleType,
-  isTypedAttribute: isTypedAttribute,
-  isVisibleAttribute: isVisibleAttribute,
-  isWritableAttribute: isWritableAttribute
-});
-
-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) {
-            return fp.assoc(UPDATED_BY_ATTRIBUTE$2, user.id, data);
-        }
-        return fp.assign(data, {
-            [CREATED_BY_ATTRIBUTE$2]: user.id,
-            [UPDATED_BY_ATTRIBUTE$2]: user.id
-        });
-    };
-
-/**
- * Create a default Strapi hook
- */ const createHook = ()=>{
-    const state = {
-        handlers: []
-    };
-    return {
-        getHandlers () {
-            return state.handlers;
-        },
-        register (handler) {
-            state.handlers.push(handler);
-            return this;
-        },
-        delete (handler) {
-            state.handlers = fp.remove(fp.eq(handler), state.handlers);
-            return this;
-        },
-        call () {
-            throw new Error('Method not implemented');
-        }
-    };
-};
-/**
- * Create an async series hook.
- * Upon execution, it will execute every handler in order with the same context
- */ const createAsyncSeriesHook = ()=>({
-        ...createHook(),
-        async call (context) {
-            for (const handler of this.getHandlers()){
-                await handler(context);
-            }
-        }
-    });
-/**
- * Create an async series waterfall hook.
- * Upon execution, it will execute every handler in order and pass the return value of the last handler to the next one
- */ const createAsyncSeriesWaterfallHook = ()=>({
-        ...createHook(),
-        async call (param) {
-            let res = param;
-            for (const handler of this.getHandlers()){
-                res = await handler(res);
-            }
-            return res;
-        }
-    });
-/**
- * Create an async parallel hook.
- * Upon execution, it will execute every registered handler in band.
- */ const createAsyncParallelHook = ()=>({
-        ...createHook(),
-        async call (context) {
-            const promises = this.getHandlers().map((handler)=>handler(fp.cloneDeep(context)));
-            return Promise.all(promises);
-        }
-    });
-/**
- * Create an async parallel hook.
- * Upon execution, it will execute every registered handler in serie and return the first result found.
- */ const createAsyncBailHook = ()=>({
-        ...createHook(),
-        async call (context) {
-            for (const handler of this.getHandlers()){
-                const result = await handler(context);
-                if (result !== undefined) {
-                    return result;
-                }
-            }
-        }
-    });
-const internals = {
-    // Internal utils
-    createHook
-};
-
-var hooks = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createAsyncBailHook: createAsyncBailHook,
-  createAsyncParallelHook: createAsyncParallelHook,
-  createAsyncSeriesHook: createAsyncSeriesHook,
-  createAsyncSeriesWaterfallHook: createAsyncSeriesWaterfallHook,
-  internals: internals
-});
-
-/**
- * Creates a new object containing various hooks used by the providers
- */ const createProviderHooksMap = ()=>({
-        // Register events
-        willRegister: createAsyncSeriesHook(),
-        didRegister: createAsyncParallelHook(),
-        // Delete events
-        willDelete: createAsyncParallelHook(),
-        didDelete: createAsyncParallelHook()
-    });
-/**
- * A Provider factory
- */ const providerFactory = (options = {})=>{
-    const { throwOnDuplicates = true } = options;
-    const state = {
-        hooks: createProviderHooksMap(),
-        registry: new Map()
-    };
-    return {
-        hooks: state.hooks,
-        async register (key, item) {
-            if (throwOnDuplicates && this.has(key)) {
-                throw new Error(`Duplicated item key: ${key}`);
-            }
-            await state.hooks.willRegister.call({
-                key,
-                value: item
-            });
-            state.registry.set(key, item);
-            await state.hooks.didRegister.call({
-                key,
-                value: fp.cloneDeep(item)
-            });
-            return this;
-        },
-        async delete (key) {
-            if (this.has(key)) {
-                const item = this.get(key);
-                await state.hooks.willDelete.call({
-                    key,
-                    value: fp.cloneDeep(item)
-                });
-                state.registry.delete(key);
-                await state.hooks.didDelete.call({
-                    key,
-                    value: fp.cloneDeep(item)
-                });
-            }
-            return this;
-        },
-        get (key) {
-            return state.registry.get(key);
-        },
-        values () {
-            return Array.from(state.registry.values());
-        },
-        keys () {
-            return Array.from(state.registry.keys());
-        },
-        has (key) {
-            return state.registry.has(key);
-        },
-        size () {
-            return state.registry.size;
-        },
-        async clear () {
-            const keys = this.keys();
-            for (const key of keys){
-                await this.delete(key);
-            }
-            return this;
-        }
-    };
-};
-
-const traverseEntity = async (visitor, options, entity)=>{
-    const { path = {
-        raw: null,
-        attribute: null
-    }, schema, getModel } = options;
-    let parent = options.parent;
-    const traverseMorphRelationTarget = async (visitor, path, entry)=>{
-        const targetSchema = getModel(entry.__type);
-        const traverseOptions = {
-            schema: targetSchema,
-            path,
-            getModel,
-            parent
-        };
-        return traverseEntity(visitor, traverseOptions, entry);
-    };
-    const traverseRelationTarget = (schema)=>async (visitor, path, entry)=>{
-            const traverseOptions = {
-                schema,
-                path,
-                getModel,
-                parent
-            };
-            return traverseEntity(visitor, traverseOptions, entry);
-        };
-    const traverseMediaTarget = async (visitor, path, entry)=>{
-        const targetSchemaUID = 'plugin::upload.file';
-        const targetSchema = getModel(targetSchemaUID);
-        const traverseOptions = {
-            schema: targetSchema,
-            path,
-            getModel,
-            parent
-        };
-        return traverseEntity(visitor, traverseOptions, entry);
-    };
-    const traverseComponent = async (visitor, path, schema, entry)=>{
-        const traverseOptions = {
-            schema,
-            path,
-            getModel,
-            parent
-        };
-        return traverseEntity(visitor, traverseOptions, entry);
-    };
-    const visitDynamicZoneEntry = async (visitor, path, entry)=>{
-        const targetSchema = getModel(entry.__component);
-        const traverseOptions = {
-            schema: targetSchema,
-            path,
-            getModel,
-            parent
-        };
-        return traverseEntity(visitor, traverseOptions, entry);
-    };
-    // End recursion
-    if (!fp.isObject(entity) || fp.isNil(schema)) {
-        return entity;
-    }
-    // Don't mutate the original entity object
-    // only clone at 1st level as the next level will get clone when traversed
-    const copy = fp.clone(entity);
-    const visitorUtils = createVisitorUtils({
-        data: copy
-    });
-    const keys = Object.keys(copy);
-    for(let i = 0; i < keys.length; i += 1){
-        const key = keys[i];
-        // Retrieve the attribute definition associated to the key from the schema
-        const attribute = schema.attributes[key];
-        const newPath = {
-            ...path
-        };
-        newPath.raw = fp.isNil(path.raw) ? key : `${path.raw}.${key}`;
-        if (!fp.isNil(attribute)) {
-            newPath.attribute = fp.isNil(path.attribute) ? key : `${path.attribute}.${key}`;
-        }
-        // Visit the current attribute
-        const visitorOptions = {
-            data: copy,
-            schema,
-            key,
-            value: copy[key],
-            attribute,
-            path: newPath,
-            getModel,
-            parent
-        };
-        await visitor(visitorOptions, visitorUtils);
-        // Extract the value for the current key (after calling the visitor)
-        const value = copy[key];
-        // Ignore Nil values or attributes
-        if (fp.isNil(value) || fp.isNil(attribute)) {
-            continue;
-        }
-        // The current attribute becomes the parent once visited
-        parent = {
-            schema,
-            key,
-            attribute,
-            path: newPath
-        };
-        if (isRelationalAttribute(attribute)) {
-            const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
-            const method = isMorphRelation ? traverseMorphRelationTarget : traverseRelationTarget(getModel(attribute.target));
-            if (fp.isArray(value)) {
-                const res = new Array(value.length);
-                for(let i = 0; i < value.length; i += 1){
-                    res[i] = await method(visitor, newPath, value[i]);
-                }
-                copy[key] = res;
-            } else {
-                copy[key] = await method(visitor, newPath, value);
-            }
-            continue;
-        }
-        if (isMediaAttribute(attribute)) {
-            // need to update copy
-            if (fp.isArray(value)) {
-                const res = new Array(value.length);
-                for(let i = 0; i < value.length; i += 1){
-                    res[i] = await traverseMediaTarget(visitor, newPath, value[i]);
-                }
-                copy[key] = res;
-            } else {
-                copy[key] = await traverseMediaTarget(visitor, newPath, value);
-            }
-            continue;
-        }
-        if (attribute.type === 'component') {
-            const targetSchema = getModel(attribute.component);
-            if (fp.isArray(value)) {
-                const res = new Array(value.length);
-                for(let i = 0; i < value.length; i += 1){
-                    res[i] = await traverseComponent(visitor, newPath, targetSchema, value[i]);
-                }
-                copy[key] = res;
-            } else {
-                copy[key] = await traverseComponent(visitor, newPath, targetSchema, value);
-            }
-            continue;
-        }
-        if (attribute.type === 'dynamiczone' && fp.isArray(value)) {
-            const res = new Array(value.length);
-            for(let i = 0; i < value.length; i += 1){
-                res[i] = await visitDynamicZoneEntry(visitor, newPath, value[i]);
-            }
-            copy[key] = res;
-            continue;
-        }
-    }
-    return copy;
-};
-const createVisitorUtils = ({ data })=>({
-        remove (key) {
-            delete data[key];
-        },
-        set (key, value) {
-            data[key] = value;
-        }
-    });
-var traverseEntity$1 = fp.curry(traverseEntity);
-
-/* eslint-disable @typescript-eslint/no-var-requires */ function importDefault(modName) {
-    const mod = require(modName);
-    return mod && mod.__esModule ? mod.default : mod;
-}
-
-var machineId = (()=>{
-    try {
-        const deviceId = nodeMachineId.machineIdSync();
-        return deviceId;
-    } catch (error) {
-        const deviceId = crypto.randomUUID();
-        return deviceId;
-    }
-});
-
-const formatYupInnerError = (yupError)=>({
-        path: fp.toPath(yupError.path),
-        message: yupError.message,
-        name: yupError.name,
-        value: yupError.value
-    });
-const formatYupErrors = (yupError)=>({
-        errors: fp.isEmpty(yupError.inner) ? [
-            formatYupInnerError(yupError)
-        ] : yupError.inner.map(formatYupInnerError),
-        message: yupError.message
-    });
-
-/* ApplicationError */ class ApplicationError extends Error {
-    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, message: yupMessage } = formatYupErrors(yupError);
-        this.message = message || yupMessage;
-        this.details = {
-            errors
-        };
-    }
-}
-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;
-    }
-}
-
-var errors = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  ApplicationError: ApplicationError,
-  ForbiddenError: ForbiddenError,
-  HttpError: httpErrors.HttpError,
-  NotFoundError: NotFoundError,
-  NotImplementedError: NotImplementedError,
-  PaginationError: PaginationError,
-  PayloadTooLargeError: PayloadTooLargeError,
-  PolicyError: PolicyError,
-  RateLimitError: RateLimitError,
-  UnauthorizedError: UnauthorizedError,
-  ValidationError: ValidationError,
-  YupValidationError: YupValidationError
-});
-
-const handleYupError = (error, errorMessage)=>{
-    throw new YupValidationError(error, errorMessage);
-};
-const defaultValidationParam = {
-    strict: true,
-    abortEarly: false
-};
-const validateYupSchema = (schema, options = {})=>async (body, errorMessage)=>{
-        try {
-            const optionsWithDefaults = fp.defaults(defaultValidationParam, options);
-            const result = await schema.validate(body, optionsWithDefaults);
-            return result;
-        } catch (e) {
-            if (e instanceof yup__namespace.ValidationError) {
-                handleYupError(e, errorMessage);
-            }
-            throw e;
-        }
-    };
-const validateYupSchemaSync = (schema, options = {})=>(body, errorMessage)=>{
-        try {
-            const optionsWithDefaults = fp.defaults(defaultValidationParam, options);
-            return schema.validateSync(body, optionsWithDefaults);
-        } catch (e) {
-            if (e instanceof yup__namespace.ValidationError) {
-                handleYupError(e, errorMessage);
-            }
-            throw e;
-        }
-    };
-
-const GROUP_OPERATORS = [
-    '$and',
-    '$or'
-];
-const WHERE_OPERATORS = [
-    '$not',
-    '$in',
-    '$notIn',
-    '$eq',
-    '$eqi',
-    '$ne',
-    '$nei',
-    '$gt',
-    '$gte',
-    '$lt',
-    '$lte',
-    '$null',
-    '$notNull',
-    '$between',
-    '$startsWith',
-    '$endsWith',
-    '$startsWithi',
-    '$endsWithi',
-    '$contains',
-    '$notContains',
-    '$containsi',
-    '$notContainsi',
-    // Experimental, only for internal use
-    '$jsonSupersetOf'
-];
-const CAST_OPERATORS = [
-    '$not',
-    '$in',
-    '$notIn',
-    '$eq',
-    '$ne',
-    '$gt',
-    '$gte',
-    '$lt',
-    '$lte',
-    '$between'
-];
-const ARRAY_OPERATORS = [
-    '$in',
-    '$notIn',
-    '$between'
-];
-const OPERATORS = {
-    where: WHERE_OPERATORS,
-    cast: CAST_OPERATORS,
-    group: GROUP_OPERATORS,
-    array: ARRAY_OPERATORS
-};
-// for performance, cache all operators in lowercase
-const OPERATORS_LOWERCASE = Object.fromEntries(Object.entries(OPERATORS).map(([key, values])=>[
-        key,
-        values.map((value)=>value.toLowerCase())
-    ]));
-const isObjKey = (key, obj)=>{
-    return key in obj;
-};
-const isOperatorOfType = (type, key, ignoreCase = false)=>{
-    if (ignoreCase) {
-        return OPERATORS_LOWERCASE[type]?.includes(key.toLowerCase()) ?? false;
-    }
-    if (isObjKey(type, OPERATORS)) {
-        return OPERATORS[type]?.includes(key) ?? false;
-    }
-    return false;
-};
-const isOperator = (key, ignoreCase = false)=>{
-    return Object.keys(OPERATORS).some((type)=>isOperatorOfType(type, key, ignoreCase));
-};
-
-const { ID_ATTRIBUTE: ID_ATTRIBUTE$3, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$3, PUBLISHED_AT_ATTRIBUTE } = constants$1;
-class InvalidOrderError extends Error {
-    constructor(){
-        super();
-        this.message = 'Invalid order. order can only be one of asc|desc|ASC|DESC';
-    }
-}
-class InvalidSortError extends Error {
-    constructor(){
-        super();
-        this.message = 'Invalid sort parameter. Expected a string, an array of strings, a sort object or an array of sort objects';
-    }
-}
-function validateOrder(order) {
-    if (!fp.isString(order) || ![
-        'asc',
-        'desc'
-    ].includes(order.toLocaleLowerCase())) {
-        throw new InvalidOrderError();
-    }
-}
-const convertCountQueryParams = (countQuery)=>{
-    return parseType({
-        type: 'boolean',
-        value: countQuery
-    });
-};
-const convertOrderingQueryParams = (ordering)=>{
-    return ordering;
-};
-const isPlainObject = (value)=>_.isPlainObject(value);
-const isStringArray$3 = (value)=>fp.isArray(value) && value.every(fp.isString);
-const createTransformer = ({ getModel })=>{
-    /**
-   * Sort query parser
-   */ const convertSortQueryParams = (sortQuery)=>{
-        if (typeof sortQuery === 'string') {
-            return convertStringSortQueryParam(sortQuery);
-        }
-        if (isStringArray$3(sortQuery)) {
-            return sortQuery.flatMap((sortValue)=>convertStringSortQueryParam(sortValue));
-        }
-        if (Array.isArray(sortQuery)) {
-            return sortQuery.map((sortValue)=>convertNestedSortQueryParam(sortValue));
-        }
-        if (isPlainObject(sortQuery)) {
-            return convertNestedSortQueryParam(sortQuery);
-        }
-        throw new InvalidSortError();
-    };
-    const convertStringSortQueryParam = (sortQuery)=>{
-        return sortQuery.split(',').map((value)=>convertSingleSortQueryParam(value));
-    };
-    const convertSingleSortQueryParam = (sortQuery)=>{
-        if (!sortQuery) {
-            return {};
-        }
-        if (!fp.isString(sortQuery)) {
-            throw new Error('Invalid sort query');
-        }
-        // split field and order param with default order to ascending
-        const [field, order = 'asc'] = sortQuery.split(':');
-        if (field.length === 0) {
-            throw new Error('Field cannot be empty');
-        }
-        validateOrder(order);
-        // TODO: field should be a valid path on an object model
-        return _.set({}, field, order);
-    };
-    const convertNestedSortQueryParam = (sortQuery)=>{
-        const transformedSort = {};
-        for (const field of Object.keys(sortQuery)){
-            const order = sortQuery[field];
-            // this is a deep sort
-            if (isPlainObject(order)) {
-                transformedSort[field] = convertNestedSortQueryParam(order);
-            } else if (typeof order === 'string') {
-                validateOrder(order);
-                transformedSort[field] = order;
-            } else {
-                throw Error(`Invalid sort type expected object or string got ${typeof order}`);
-            }
-        }
-        return transformedSort;
-    };
-    /**
-   * Start query parser
-   */ const convertStartQueryParams = (startQuery)=>{
-        const startAsANumber = fp.toNumber(startQuery);
-        if (!_.isInteger(startAsANumber) || startAsANumber < 0) {
-            throw new Error(`convertStartQueryParams expected a positive integer got ${startAsANumber}`);
-        }
-        return startAsANumber;
-    };
-    /**
-   * Limit query parser
-   */ const convertLimitQueryParams = (limitQuery)=>{
-        const limitAsANumber = fp.toNumber(limitQuery);
-        if (!_.isInteger(limitAsANumber) || limitAsANumber !== -1 && limitAsANumber < 0) {
-            throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
-        }
-        if (limitAsANumber === -1) {
-            return undefined;
-        }
-        return limitAsANumber;
-    };
-    const convertPageQueryParams = (page)=>{
-        const pageVal = fp.toNumber(page);
-        if (!fp.isInteger(pageVal) || pageVal <= 0) {
-            throw new PaginationError(`Invalid 'page' parameter. Expected an integer > 0, received: ${page}`);
-        }
-        return pageVal;
-    };
-    const convertPageSizeQueryParams = (pageSize, page)=>{
-        const pageSizeVal = fp.toNumber(pageSize);
-        if (!fp.isInteger(pageSizeVal) || pageSizeVal <= 0) {
-            throw new PaginationError(`Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`);
-        }
-        return pageSizeVal;
-    };
-    const validatePaginationParams = (page, pageSize, start, limit)=>{
-        const isPagePagination = !fp.isNil(page) || !fp.isNil(pageSize);
-        const isOffsetPagination = !fp.isNil(start) || !fp.isNil(limit);
-        if (isPagePagination && isOffsetPagination) {
-            throw new PaginationError('Invalid pagination attributes. The page parameters are incorrect and must be in the pagination object');
-        }
-    };
-    class InvalidPopulateError extends Error {
-        constructor(){
-            super();
-            this.message = 'Invalid populate parameter. Expected a string, an array of strings, a populate object';
-        }
-    }
-    // NOTE: we could support foo.* or foo.bar.* etc later on
-    const convertPopulateQueryParams = (populate, schema, depth = 0)=>{
-        if (depth === 0 && populate === '*') {
-            return true;
-        }
-        if (typeof populate === 'string') {
-            return populate.split(',').map((value)=>_.trim(value));
-        }
-        if (Array.isArray(populate)) {
-            // map convert
-            return _.uniq(populate.flatMap((value)=>{
-                if (typeof value !== 'string') {
-                    throw new InvalidPopulateError();
-                }
-                return value.split(',').map((value)=>_.trim(value));
-            }));
-        }
-        if (_.isPlainObject(populate)) {
-            return convertPopulateObject(populate, schema);
-        }
-        throw new InvalidPopulateError();
-    };
-    const hasPopulateFragmentDefined = (populate)=>{
-        return typeof populate === 'object' && 'on' in populate && !fp.isNil(populate.on);
-    };
-    const hasCountDefined = (populate)=>{
-        return typeof populate === 'object' && 'count' in populate && typeof populate.count === 'boolean';
-    };
-    const convertPopulateObject = (populate, schema)=>{
-        if (!schema) {
-            return {};
-        }
-        const { attributes } = schema;
-        return Object.entries(populate).reduce((acc, [key, subPopulate])=>{
-            // Try converting strings to regular booleans if possible
-            if (_.isString(subPopulate)) {
-                try {
-                    const subPopulateAsBoolean = parseType({
-                        type: 'boolean',
-                        value: subPopulate
-                    });
-                    // Only true is accepted as a boolean populate value
-                    return subPopulateAsBoolean ? {
-                        ...acc,
-                        [key]: true
-                    } : acc;
-                } catch  {
-                // ignore
-                }
-            }
-            if (_.isBoolean(subPopulate)) {
-                // Only true is accepted as a boolean populate value
-                return subPopulate === true ? {
-                    ...acc,
-                    [key]: true
-                } : acc;
-            }
-            const attribute = attributes[key];
-            if (!attribute) {
-                return acc;
-            }
-            // Allow adding an 'on' strategy to populate queries for morphTo relations and dynamic zones
-            const isMorphLikeRelationalAttribute = isDynamicZoneAttribute(attribute) || isMorphToRelationalAttribute(attribute);
-            if (isMorphLikeRelationalAttribute) {
-                const hasInvalidProperties = Object.keys(subPopulate).some((key)=>![
-                        'populate',
-                        'on',
-                        'count'
-                    ].includes(key));
-                if (hasInvalidProperties) {
-                    throw new Error(`Invalid nested populate for ${schema.info?.singularName}.${key} (${schema.uid}). Expected a fragment ("on") or "count" but found ${JSON.stringify(subPopulate)}`);
-                }
-                /**
-         * Validate nested population queries in the context of a polymorphic attribute (dynamic zone, morph relation).
-         *
-         * If 'populate' exists in subPopulate, its value should be constrained to a wildcard ('*').
-         */ if ('populate' in subPopulate && subPopulate.populate !== '*') {
-                    throw new Error(`Invalid nested population query detected. When using 'populate' within polymorphic structures, ` + `its value must be '*' to indicate all second level links. Specific field targeting is not supported here. ` + `Consider using the fragment API for more granular population control.`);
-                }
-                // TODO: Remove the possibility to have multiple properties at the same time (on/count/populate)
-                const newSubPopulate = {};
-                // case: { populate: '*' }
-                if ('populate' in subPopulate) {
-                    Object.assign(newSubPopulate, {
-                        populate: true
-                    });
-                }
-                // case: { on: { <clauses> } }
-                if (hasPopulateFragmentDefined(subPopulate)) {
-                    // If the fragment API is used, it applies the transformation to every
-                    // sub-populate, then assign the result to the new sub-populate
-                    Object.assign(newSubPopulate, {
-                        on: Object.entries(subPopulate.on).reduce((acc, [type, typeSubPopulate])=>({
-                                ...acc,
-                                [type]: convertNestedPopulate(typeSubPopulate, getModel(type))
-                            }), {})
-                    });
-                }
-                // case: { count: true | false }
-                if (hasCountDefined(subPopulate)) {
-                    Object.assign(newSubPopulate, {
-                        count: subPopulate.count
-                    });
-                }
-                return {
-                    ...acc,
-                    [key]: newSubPopulate
-                };
-            }
-            // Edge case when trying to use the fragment ('on') on a non-morph like attribute
-            if (!isMorphLikeRelationalAttribute && hasPopulateFragmentDefined(subPopulate)) {
-                throw new Error(`Using fragments is not permitted to populate "${key}" in "${schema.uid}"`);
-            }
-            // NOTE: Retrieve the target schema UID.
-            // Only handles basic relations, medias and component since it's not possible
-            // to populate with options for a dynamic zone or a polymorphic relation
-            let targetSchemaUID;
-            if (attribute.type === 'relation') {
-                targetSchemaUID = attribute.target;
-            } else if (attribute.type === 'component') {
-                targetSchemaUID = attribute.component;
-            } else if (attribute.type === 'media') {
-                targetSchemaUID = 'plugin::upload.file';
-            } else {
-                return acc;
-            }
-            const targetSchema = getModel(targetSchemaUID);
-            // ignore the sub-populate for the current key if there is no schema associated
-            if (!targetSchema) {
-                return acc;
-            }
-            const populateObject = convertNestedPopulate(subPopulate, targetSchema);
-            if (!populateObject) {
-                return acc;
-            }
-            return {
-                ...acc,
-                [key]: populateObject
-            };
-        }, {});
-    };
-    const convertNestedPopulate = (subPopulate, schema)=>{
-        if (_.isString(subPopulate)) {
-            return parseType({
-                type: 'boolean',
-                value: subPopulate,
-                forceCast: true
-            });
-        }
-        if (_.isBoolean(subPopulate)) {
-            return subPopulate;
-        }
-        if (!isPlainObject(subPopulate)) {
-            throw new Error(`Invalid nested populate. Expected '*' or an object`);
-        }
-        const { sort, filters, fields, populate, count, ordering, page, pageSize, start, limit } = subPopulate;
-        const query = {};
-        if (sort) {
-            query.orderBy = convertSortQueryParams(sort);
-        }
-        if (filters) {
-            query.where = convertFiltersQueryParams(filters, schema);
-        }
-        if (fields) {
-            query.select = convertFieldsQueryParams(fields, schema);
-        }
-        if (populate) {
-            query.populate = convertPopulateQueryParams(populate, schema);
-        }
-        if (count) {
-            query.count = convertCountQueryParams(count);
-        }
-        if (ordering) {
-            query.ordering = convertOrderingQueryParams(ordering);
-        }
-        validatePaginationParams(page, pageSize, start, limit);
-        if (!fp.isNil(page)) {
-            query.page = convertPageQueryParams(page);
-        }
-        if (!fp.isNil(pageSize)) {
-            query.pageSize = convertPageSizeQueryParams(pageSize, page);
-        }
-        if (!fp.isNil(start)) {
-            query.offset = convertStartQueryParams(start);
-        }
-        if (!fp.isNil(limit)) {
-            query.limit = convertLimitQueryParams(limit);
-        }
-        return query;
-    };
-    // TODO: ensure field is valid in content types (will probably have to check strapi.contentTypes since it can be a string.path)
-    const convertFieldsQueryParams = (fields, schema, depth = 0)=>{
-        if (depth === 0 && fields === '*') {
-            return undefined;
-        }
-        if (typeof fields === 'string') {
-            const fieldsValues = fields.split(',').map((value)=>_.trim(value));
-            // NOTE: Only include the doc id if it's a content type
-            if (schema?.modelType === 'contentType') {
-                return _.uniq([
-                    ID_ATTRIBUTE$3,
-                    DOC_ID_ATTRIBUTE$3,
-                    ...fieldsValues
-                ]);
-            }
-            return _.uniq([
-                ID_ATTRIBUTE$3,
-                ...fieldsValues
-            ]);
-        }
-        if (isStringArray$3(fields)) {
-            // map convert
-            const fieldsValues = fields.flatMap((value)=>convertFieldsQueryParams(value, schema, depth + 1)).filter((v)=>!fp.isNil(v));
-            // NOTE: Only include the doc id if it's a content type
-            if (schema?.modelType === 'contentType') {
-                return _.uniq([
-                    ID_ATTRIBUTE$3,
-                    DOC_ID_ATTRIBUTE$3,
-                    ...fieldsValues
-                ]);
-            }
-            return _.uniq([
-                ID_ATTRIBUTE$3,
-                ...fieldsValues
-            ]);
-        }
-        throw new Error('Invalid fields parameter. Expected a string or an array of strings');
-    };
-    const isValidSchemaAttribute = (key, schema)=>{
-        if ([
-            DOC_ID_ATTRIBUTE$3,
-            ID_ATTRIBUTE$3
-        ].includes(key)) {
-            return true;
-        }
-        if (!schema) {
-            return false;
-        }
-        return Object.keys(schema.attributes).includes(key);
-    };
-    const convertFiltersQueryParams = (filters, schema)=>{
-        // Filters need to be either an array or an object
-        // Here we're only checking for 'object' type since typeof [] => object and typeof {} => object
-        if (!fp.isObject(filters)) {
-            throw new Error('The filters parameter must be an object or an array');
-        }
-        // Don't mutate the original object
-        const filtersCopy = fp.cloneDeep(filters);
-        return convertAndSanitizeFilters(filtersCopy, schema);
-    };
-    const convertAndSanitizeFilters = (filters, schema)=>{
-        if (Array.isArray(filters)) {
-            return filters// Sanitize each filter
-            .map((filter)=>convertAndSanitizeFilters(filter, schema))// Filter out empty filters
-            .filter((filter)=>!isPlainObject(filter) || !fp.isEmpty(filter));
-        }
-        if (!isPlainObject(filters)) {
-            return filters;
-        }
-        const removeOperator = (operator)=>delete filters[operator];
-        // Here, `key` can either be an operator or an attribute name
-        for (const [key, value] of Object.entries(filters)){
-            const attribute = fp.get(key, schema?.attributes);
-            const validKey = isOperator(key) || isValidSchemaAttribute(key, schema);
-            if (!validKey) {
-                removeOperator(key);
-            } else if (attribute) {
-                // Relations
-                if (attribute.type === 'relation') {
-                    filters[key] = convertAndSanitizeFilters(value, getModel(attribute.target));
-                } else if (attribute.type === 'component') {
-                    filters[key] = convertAndSanitizeFilters(value, getModel(attribute.component));
-                } else if (attribute.type === 'media') {
-                    filters[key] = convertAndSanitizeFilters(value, getModel('plugin::upload.file'));
-                } else if (attribute.type === 'dynamiczone') {
-                    removeOperator(key);
-                } else if (attribute.type === 'password') {
-                    // Always remove password attributes from filters object
-                    removeOperator(key);
-                } else {
-                    filters[key] = convertAndSanitizeFilters(value, schema);
-                }
-            } else if ([
-                '$null',
-                '$notNull'
-            ].includes(key)) {
-                filters[key] = parseType({
-                    type: 'boolean',
-                    value: filters[key],
-                    forceCast: true
-                });
-            } else if (fp.isObject(value)) {
-                filters[key] = convertAndSanitizeFilters(value, schema);
-            }
-            // Remove empty objects & arrays
-            if (isPlainObject(filters[key]) && fp.isEmpty(filters[key])) {
-                removeOperator(key);
-            }
-        }
-        return filters;
-    };
-    const convertStatusParams = (status, query = {})=>{
-        // NOTE: this is the query layer filters not the document/entity service filters
-        query.filters = ({ meta })=>{
-            const contentType = getModel(meta.uid);
-            // Ignore if target model has disabled DP, as it doesn't make sense to filter by its status
-            if (!contentType || !hasDraftAndPublish(contentType)) {
-                return {};
-            }
-            return {
-                [PUBLISHED_AT_ATTRIBUTE]: {
-                    $null: status === 'draft'
-                }
-            };
-        };
-    };
-    const transformQueryParams = (uid, params)=>{
-        // NOTE: can be a CT, a Compo or nothing in the case of polymorphism (DZ & morph relations)
-        const schema = getModel(uid);
-        const query = {};
-        const { _q, sort, filters, fields, populate, page, pageSize, start, limit, status, ...rest } = params;
-        if (!fp.isNil(status)) {
-            convertStatusParams(status, query);
-        }
-        if (!fp.isNil(_q)) {
-            query._q = _q;
-        }
-        if (!fp.isNil(sort)) {
-            query.orderBy = convertSortQueryParams(sort);
-        }
-        if (!fp.isNil(filters)) {
-            query.where = convertFiltersQueryParams(filters, schema);
-        }
-        if (!fp.isNil(fields)) {
-            query.select = convertFieldsQueryParams(fields, schema);
-        }
-        if (!fp.isNil(populate)) {
-            query.populate = convertPopulateQueryParams(populate, schema);
-        }
-        validatePaginationParams(page, pageSize, start, limit);
-        if (!fp.isNil(page)) {
-            query.page = convertPageQueryParams(page);
-        }
-        if (!fp.isNil(pageSize)) {
-            query.pageSize = convertPageSizeQueryParams(pageSize, page);
-        }
-        if (!fp.isNil(start)) {
-            query.offset = convertStartQueryParams(start);
-        }
-        if (!fp.isNil(limit)) {
-            query.limit = convertLimitQueryParams(limit);
-        }
-        return {
-            ...rest,
-            ...query
-        };
-    };
-    return {
-        private_convertSortQueryParams: convertSortQueryParams,
-        private_convertStartQueryParams: convertStartQueryParams,
-        private_convertLimitQueryParams: convertLimitQueryParams,
-        private_convertPopulateQueryParams: convertPopulateQueryParams,
-        private_convertFiltersQueryParams: convertFiltersQueryParams,
-        private_convertFieldsQueryParams: convertFieldsQueryParams,
-        transformQueryParams
-    };
-};
-
-var convertQueryParams = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createTransformer: createTransformer
-});
-
-function pipe(...fns) {
-    const [firstFn, ...fnRest] = fns;
-    return async (...args)=>{
-        let res = await firstFn.apply(firstFn, args);
-        for(let i = 0; i < fnRest.length; i += 1){
-            res = await fnRest[i](res);
-        }
-        return res;
-    };
-}
-const map = fp.curry(pMap);
-const reduce = (mixedArray)=>async (iteratee, initialValue)=>{
-        let acc = initialValue;
-        for(let i = 0; i < mixedArray.length; i += 1){
-            acc = await iteratee(acc, await mixedArray[i], i);
-        }
-        return acc;
-    };
-
-var async = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  map: map,
-  pipe: pipe,
-  reduce: reduce
-});
-
-const visitor$8 = ({ key, attribute }, { remove })=>{
-    if (attribute?.type === 'password') {
-        remove(key);
-    }
-};
-
-const visitor$7 = ({ schema, key, attribute }, { remove })=>{
-    if (!attribute) {
-        return;
-    }
-    const isPrivate = attribute.private === true || isPrivateAttribute(schema, key);
-    if (isPrivate) {
-        remove(key);
-    }
-};
-
-const 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 isPolymorphic = (attribute)=>[
-        'morphOne',
-        'morphMany',
-        'morphToOne',
-        'morphToMany'
-    ].includes(attribute.relation);
-const constants = {
-    MANY_RELATIONS
-};
-// Valid keys in the `options` property of relations reordering
-// The value for each key must be a function that returns true if it is a valid value
-const VALID_RELATION_ORDERING_KEYS = {
-    strict: fp.isBoolean
-};
-
-var relations = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  VALID_RELATION_ORDERING_KEYS: VALID_RELATION_ORDERING_KEYS,
-  constants: constants,
-  getRelationalFields: getRelationalFields,
-  isAnyToMany: isAnyToMany,
-  isAnyToOne: isAnyToOne,
-  isManyToAny: isManyToAny,
-  isOneToAny: isOneToAny,
-  isPolymorphic: isPolymorphic
-});
-
-const ACTIONS_TO_VERIFY$1 = [
-    'find'
-];
-const { CREATED_BY_ATTRIBUTE: CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE: UPDATED_BY_ATTRIBUTE$1 } = constants$1;
-var removeRestrictedRelations = ((auth)=>async ({ data, key, attribute, schema }, { remove, set })=>{
-        if (!attribute) {
-            return;
-        }
-        const isRelation = attribute.type === 'relation';
-        if (!isRelation) {
-            return;
-        }
-        const handleMorphRelation = async ()=>{
-            const elements = data[key];
-            if ('connect' in elements || 'set' in elements || 'disconnect' in elements) {
-                const newValue = {};
-                const connect = await handleMorphElements(elements.connect || []);
-                const relSet = await handleMorphElements(elements.set || []);
-                const disconnect = await handleMorphElements(elements.disconnect || []);
-                if (connect.length > 0) {
-                    newValue.connect = connect;
-                }
-                if (relSet.length > 0) {
-                    newValue.set = relSet;
-                }
-                if (disconnect.length > 0) {
-                    newValue.disconnect = disconnect;
-                }
-                // TODO: this should technically be in its own visitor to check morph options, but for now we'll handle it here
-                if ('options' in elements && typeof elements.options === 'object' && elements.options !== null) {
-                    const filteredOptions = {};
-                    // Iterate through the keys of elements.options
-                    Object.keys(elements.options).forEach((key)=>{
-                        const validator = VALID_RELATION_ORDERING_KEYS[key];
-                        // Ensure the key exists in VALID_RELATION_ORDERING_KEYS and the validator is defined before calling it
-                        if (validator && validator(elements.options[key])) {
-                            filteredOptions[key] = elements.options[key];
-                        }
-                    });
-                    // Assign the filtered options back to newValue
-                    newValue.options = filteredOptions;
-                } else {
-                    newValue.options = {};
-                }
-                set(key, newValue);
-            } else {
-                const newMorphValue = await handleMorphElements(elements);
-                if (newMorphValue.length) {
-                    set(key, newMorphValue);
-                }
-            }
-        };
-        const handleMorphElements = async (elements)=>{
-            const allowedElements = [];
-            if (!fp.isArray(elements)) {
-                return allowedElements;
-            }
-            for (const element of elements){
-                if (!fp.isObject(element) || !('__type' in element)) {
-                    continue;
-                }
-                const scopes = ACTIONS_TO_VERIFY$1.map((action)=>`${element.__type}.${action}`);
-                const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
-                if (isAllowed) {
-                    allowedElements.push(element);
-                }
-            }
-            return allowedElements;
-        };
-        const handleRegularRelation = async ()=>{
-            const scopes = ACTIONS_TO_VERIFY$1.map((action)=>`${attribute.target}.${action}`);
-            const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
-            // If the authenticated user don't have access to any of the scopes, then remove the field
-            if (!isAllowed) {
-                remove(key);
-            }
-        };
-        const isCreatorRelation = [
-            CREATED_BY_ATTRIBUTE$1,
-            UPDATED_BY_ATTRIBUTE$1
-        ].includes(key);
-        // Polymorphic relations
-        if (isMorphToRelationalAttribute(attribute)) {
-            await handleMorphRelation();
-            return;
-        }
-        // Creator relations
-        if (isCreatorRelation && schema.options?.populateCreatorFields) {
-            // do nothing
-            return;
-        }
-        // Regular relations
-        await handleRegularRelation();
-    });
-const hasAccessToSomeScopes$1 = async (scopes, auth)=>{
-    for (const scope of scopes){
-        try {
-            await strapi.auth.verify(auth, {
-                scope
-            });
-            return true;
-        } catch  {
-            continue;
-        }
-    }
-    return false;
-};
-
-const visitor$6 = ({ key, attribute }, { remove })=>{
-    if (isMorphToRelationalAttribute(attribute)) {
-        remove(key);
-    }
-};
-
-const visitor$5 = ({ key, attribute }, { remove })=>{
-    if (isDynamicZoneAttribute(attribute)) {
-        remove(key);
-    }
-};
-
-var removeDisallowedFields = ((allowedFields = null)=>({ key, path: { attribute: path } }, { remove })=>{
-        // All fields are allowed
-        if (allowedFields === null) {
-            return;
-        }
-        // Throw on invalid formats
-        if (!(fp.isArray(allowedFields) && allowedFields.every(fp.isString))) {
-            throw new TypeError(`Expected array of strings for allowedFields but got "${typeof allowedFields}"`);
-        }
-        if (fp.isNil(path)) {
-            return;
-        }
-        const containedPaths = getContainedPaths$1(path);
-        /**
-     * Tells if the current path should be kept or not based
-     * on the success of the check functions for any of the allowed paths.
-     *
-     * The check functions are defined as follow:
-     *
-     * `containedPaths.includes(p)`
-     * @example
-     * ```js
-     * const path = 'foo.bar.field';
-     * const p = 'foo.bar';
-     * // it should match
-     *
-     * const path = 'foo.bar.field';
-     * const p = 'bar.foo';
-     * // it shouldn't match
-     *
-     * const path = 'foo.bar';
-     * const p = 'foo.bar.field';
-     * // it should match but isn't handled by this check
-     * ```
-     *
-     * `p.startsWith(`${path}.`)`
-     * @example
-     * ```js
-     * const path = 'foo.bar';
-     * const p = 'foo.bar.field';
-     * // it should match
-     *
-     * const path = 'foo.bar.field';
-     * const p = 'bar.foo';
-     * // it shouldn't match
-     *
-     * const path = 'foo.bar.field';
-     * const p = 'foo.bar';
-     * // it should match but isn't handled by this check
-     * ```
-     */ const isPathAllowed = allowedFields.some((p)=>containedPaths.includes(p) || p.startsWith(`${path}.`));
-        if (isPathAllowed) {
-            return;
-        }
-        // Remove otherwise
-        remove(key);
-    });
-/**
- * Retrieve the list of allowed paths based on the given path
- *
- * @example
- * ```js
- * const containedPaths = getContainedPaths('foo');
- * // ['foo']
- *
- *  * const containedPaths = getContainedPaths('foo.bar');
- * // ['foo', 'foo.bar']
- *
- *  * const containedPaths = getContainedPaths('foo.bar.field');
- * // ['foo', 'foo.bar', 'foo.bar.field']
- * ```
- */ const getContainedPaths$1 = (path)=>{
-    const parts = fp.toPath(path);
-    return parts.reduce((acc, value, index, list)=>{
-        return [
-            ...acc,
-            list.slice(0, index + 1).join('.')
-        ];
-    }, []);
-};
-
-var removeRestrictedFields = ((restrictedFields = null)=>({ key, path: { attribute: path } }, { remove })=>{
-        // Remove all fields
-        if (restrictedFields === null) {
-            remove(key);
-            return;
-        }
-        // Throw on invalid formats
-        if (!(fp.isArray(restrictedFields) && restrictedFields.every(fp.isString))) {
-            throw new TypeError(`Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`);
-        }
-        // Remove if an exact match was found
-        if (restrictedFields.includes(path)) {
-            remove(key);
-            return;
-        }
-        // Remove nested matches
-        const isRestrictedNested = restrictedFields.some((allowedPath)=>path?.toString().startsWith(`${allowedPath}.`));
-        if (isRestrictedNested) {
-            remove(key);
-        }
-    });
-
-const visitor$4 = ({ schema, key, value }, { set })=>{
-    if (key === '' && value === '*') {
-        const { attributes } = schema;
-        const newPopulateQuery = Object.entries(attributes).filter(([, attribute])=>[
-                'relation',
-                'component',
-                'media',
-                'dynamiczone'
-            ].includes(attribute.type)).reduce((acc, [key])=>({
-                ...acc,
-                [key]: true
-            }), {});
-        set('', newPopulateQuery);
-    }
-};
-
-var index$4 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  expandWildcardPopulate: visitor$4,
-  removeDisallowedFields: removeDisallowedFields,
-  removeDynamicZones: visitor$5,
-  removeMorphToRelations: visitor$6,
-  removePassword: visitor$8,
-  removePrivate: visitor$7,
-  removeRestrictedFields: removeRestrictedFields,
-  removeRestrictedRelations: removeRestrictedRelations
-});
-
-const DEFAULT_PATH = {
-    raw: null,
-    attribute: null
-};
-var traverseFactory = (()=>{
-    const state = {
-        parsers: [],
-        interceptors: [],
-        ignore: [],
-        handlers: {
-            attributes: [],
-            common: []
-        }
-    };
-    const traverse = async (visitor, options, data)=>{
-        const { path = DEFAULT_PATH, parent, schema, getModel } = options ?? {};
-        // interceptors
-        for (const { predicate, handler } of state.interceptors){
-            if (predicate(data)) {
-                return handler(visitor, options, data, {
-                    recurse: traverse
-                });
-            }
-        }
-        // parsers
-        const parser = state.parsers.find((parser)=>parser.predicate(data))?.parser;
-        const utils = parser?.(data);
-        // Return the data untouched if we don't know how to traverse it
-        if (!utils) {
-            return data;
-        }
-        // main loop
-        let out = utils.transform(data);
-        const keys = utils.keys(out);
-        for (const key of keys){
-            const attribute = schema?.attributes?.[key];
-            const newPath = {
-                ...path
-            };
-            newPath.raw = fp.isNil(path.raw) ? key : `${path.raw}.${key}`;
-            if (!fp.isNil(attribute)) {
-                newPath.attribute = fp.isNil(path.attribute) ? key : `${path.attribute}.${key}`;
-            }
-            // visitors
-            const visitorOptions = {
-                key,
-                value: utils.get(key, out),
-                attribute,
-                schema,
-                path: newPath,
-                data: out,
-                getModel,
-                parent
-            };
-            const transformUtils = {
-                remove (key) {
-                    out = utils.remove(key, out);
-                },
-                set (key, value) {
-                    out = utils.set(key, value, out);
-                },
-                recurse: traverse
-            };
-            await visitor(visitorOptions, fp.pick([
-                'remove',
-                'set'
-            ], transformUtils));
-            const value = utils.get(key, out);
-            const createContext = ()=>({
-                    key,
-                    value,
-                    attribute,
-                    schema,
-                    path: newPath,
-                    data: out,
-                    visitor,
-                    getModel,
-                    parent
-                });
-            // ignore
-            const ignoreCtx = createContext();
-            const shouldIgnore = state.ignore.some((predicate)=>predicate(ignoreCtx));
-            if (shouldIgnore) {
-                continue;
-            }
-            // handlers
-            const handlers = [
-                ...state.handlers.common,
-                ...state.handlers.attributes
-            ];
-            for await (const handler of handlers){
-                const ctx = createContext();
-                const pass = await handler.predicate(ctx);
-                if (pass) {
-                    await handler.handler(ctx, fp.pick([
-                        'recurse',
-                        'set'
-                    ], transformUtils));
-                }
-            }
-        }
-        return out;
-    };
-    return {
-        traverse,
-        intercept (predicate, handler) {
-            state.interceptors.push({
-                predicate,
-                handler
-            });
-            return this;
-        },
-        parse (predicate, parser) {
-            state.parsers.push({
-                predicate,
-                parser
-            });
-            return this;
-        },
-        ignore (predicate) {
-            state.ignore.push(predicate);
-            return this;
-        },
-        on (predicate, handler) {
-            state.handlers.common.push({
-                predicate,
-                handler
-            });
-            return this;
-        },
-        onAttribute (predicate, handler) {
-            state.handlers.attributes.push({
-                predicate,
-                handler
-            });
-            return this;
-        },
-        onRelation (handler) {
-            return this.onAttribute(({ attribute })=>attribute?.type === 'relation', handler);
-        },
-        onMedia (handler) {
-            return this.onAttribute(({ attribute })=>attribute?.type === 'media', handler);
-        },
-        onComponent (handler) {
-            return this.onAttribute(({ attribute })=>attribute?.type === 'component', handler);
-        },
-        onDynamicZone (handler) {
-            return this.onAttribute(({ attribute })=>attribute?.type === 'dynamiczone', handler);
-        }
-    };
-});
-
-const isObj$2 = (value)=>fp.isObject(value);
-const filters = traverseFactory().intercept(// Intercept filters arrays and apply the traversal to each one individually
-fp.isArray, async (visitor, options, filters, { recurse })=>{
-    return Promise.all(filters.map((filter, i)=>{
-        // In filters, only operators such as $and, $in, $notIn or $or and implicit operators like [...]
-        // can have a value array, thus we can update the raw path but not the attribute one
-        const newPath = options.path ? {
-            ...options.path,
-            raw: `${options.path.raw}[${i}]`
-        } : options.path;
-        return recurse(visitor, {
-            ...options,
-            path: newPath
-        }, filter);
-    })).then((res)=>res.filter((val)=>!(fp.isObject(val) && fp.isEmpty(val))));
-}).intercept(// Ignore non object filters and return the value as-is
-(filters)=>!fp.isObject(filters), (_, __, filters)=>{
-    return filters;
-})// Parse object values
-.parse(isObj$2, ()=>({
-        transform: fp.cloneDeep,
-        remove (key, data) {
-            return fp.omit(key, data);
-        },
-        set (key, value, data) {
-            return {
-                ...data,
-                [key]: value
-            };
-        },
-        keys (data) {
-            return Object.keys(data);
-        },
-        get (key, data) {
-            return data[key];
-        }
-    }))// Ignore null or undefined values
-.ignore(({ value })=>fp.isNil(value))// Recursion on operators (non attributes)
-.on(({ attribute })=>fp.isNil(attribute), async ({ key, visitor, path, value, schema, getModel, attribute }, { set, recurse })=>{
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    set(key, await recurse(visitor, {
-        schema,
-        path,
-        getModel,
-        parent
-    }, value));
-})// Handle relation recursion
-.onRelation(async ({ key, attribute, visitor, path, value, schema, getModel }, { set, recurse })=>{
-    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
-    if (isMorphRelation) {
-        return;
-    }
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const targetSchemaUID = attribute.target;
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-}).onComponent(async ({ key, attribute, visitor, path, schema, value, getModel }, { set, recurse })=>{
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const targetSchema = getModel(attribute.component);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-})// Handle media recursion
-.onMedia(async ({ key, visitor, path, schema, attribute, value, getModel }, { set, recurse })=>{
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const targetSchemaUID = 'plugin::upload.file';
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-});
-var traverseQueryFilters = fp.curry(filters.traverse);
-
-const ORDERS = {
-    asc: 'asc',
-    desc: 'desc'
-};
-const ORDER_VALUES = Object.values(ORDERS);
-const isSortOrder = (value)=>ORDER_VALUES.includes(value.toLowerCase());
-const isStringArray$2 = (value)=>Array.isArray(value) && value.every(fp.isString);
-const isObjectArray = (value)=>Array.isArray(value) && value.every(fp.isObject);
-const isNestedSorts = (value)=>fp.isString(value) && value.split(',').length > 1;
-const isObj$1 = (value)=>fp.isObject(value);
-const sort = traverseFactory().intercept(// String with chained sorts (foo,bar,foobar) => split, map(recurse), then recompose
-isNestedSorts, async (visitor, options, sort, { recurse })=>{
-    return Promise.all(sort.split(',').map(fp.trim).map((nestedSort)=>recurse(visitor, options, nestedSort))).then((res)=>res.filter((part)=>!fp.isEmpty(part)).join(','));
-}).intercept(// Array of strings ['foo', 'foo,bar'] => map(recurse), then filter out empty items
-isStringArray$2, async (visitor, options, sort, { recurse })=>{
-    return Promise.all(sort.map((nestedSort)=>recurse(visitor, options, nestedSort))).then((res)=>res.filter((nestedSort)=>!fp.isEmpty(nestedSort)));
-}).intercept(// Array of objects [{ foo: 'asc' }, { bar: 'desc', baz: 'asc' }] => map(recurse), then filter out empty items
-isObjectArray, async (visitor, options, sort, { recurse })=>{
-    return Promise.all(sort.map((nestedSort)=>recurse(visitor, options, nestedSort))).then((res)=>res.filter((nestedSort)=>!fp.isEmpty(nestedSort)));
-})// Parse string values
-.parse(fp.isString, ()=>{
-    const tokenize = fp.pipe(fp.split('.'), fp.map(fp.split(':')), fp.flatten);
-    const recompose = (parts)=>{
-        if (parts.length === 0) {
-            return undefined;
-        }
-        return parts.reduce((acc, part)=>{
-            if (fp.isEmpty(part)) {
-                return acc;
-            }
-            if (acc === '') {
-                return part;
-            }
-            return isSortOrder(part) ? `${acc}:${part}` : `${acc}.${part}`;
-        }, '');
-    };
-    return {
-        transform: fp.trim,
-        remove (key, data) {
-            const [root] = tokenize(data);
-            return root === key ? undefined : data;
-        },
-        set (key, value, data) {
-            const [root] = tokenize(data);
-            if (root !== key) {
-                return data;
-            }
-            return fp.isNil(value) ? root : `${root}.${value}`;
-        },
-        keys (data) {
-            const v = fp.first(tokenize(data));
-            return v ? [
-                v
-            ] : [];
-        },
-        get (key, data) {
-            const [root, ...rest] = tokenize(data);
-            return key === root ? recompose(rest) : undefined;
-        }
-    };
-})// Parse object values
-.parse(isObj$1, ()=>({
-        transform: fp.cloneDeep,
-        remove (key, data) {
-            // eslint-disable-next-line no-unused-vars
-            const { [key]: ignored, ...rest } = data;
-            return rest;
-        },
-        set (key, value, data) {
-            return {
-                ...data,
-                [key]: value
-            };
-        },
-        keys (data) {
-            return Object.keys(data);
-        },
-        get (key, data) {
-            return data[key];
-        }
-    }))// Handle deep sort on relation
-.onRelation(async ({ key, value, attribute, visitor, path, getModel, schema }, { set, recurse })=>{
-    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
-    if (isMorphRelation) {
-        return;
-    }
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const targetSchemaUID = attribute.target;
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-})// Handle deep sort on media
-.onMedia(async ({ key, path, schema, attribute, visitor, value, getModel }, { recurse, set })=>{
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const targetSchemaUID = 'plugin::upload.file';
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-})// Handle deep sort on components
-.onComponent(async ({ key, value, visitor, path, schema, attribute, getModel }, { recurse, set })=>{
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const targetSchema = getModel(attribute.component);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-});
-var traverseQuerySort = fp.curry(sort.traverse);
-
-const isKeyword = (keyword)=>{
-    return ({ key, attribute })=>{
-        return !attribute && keyword === key;
-    };
-};
-const isWildcard = (value)=>value === '*';
-const isPopulateString = (value)=>{
-    return fp.isString(value) && !isWildcard(value);
-};
-const isStringArray$1 = (value)=>fp.isArray(value) && value.every(fp.isString);
-const isObj = (value)=>fp.isObject(value);
-const populate = traverseFactory().intercept(isPopulateString, async (visitor, options, populate, { recurse })=>{
-    /**
-     * Ensure the populate clause its in the extended format ( { populate: { ... } }, and not just a string)
-     * This gives a consistent structure to track the "parent" node of each nested populate clause
-     */ const populateObject = pathsToObjectPopulate([
-        populate
-    ]);
-    const traversedPopulate = await recurse(visitor, options, populateObject);
-    const [result] = objectPopulateToPaths(traversedPopulate);
-    return result;
-})// Array of strings ['foo', 'bar.baz'] => map(recurse), then filter out empty items
-.intercept(isStringArray$1, async (visitor, options, populate, { recurse })=>{
-    const paths = await Promise.all(populate.map((subClause)=>recurse(visitor, options, subClause)));
-    return paths.filter((item)=>!fp.isNil(item));
-})// for wildcard, generate custom utilities to modify the values
-.parse(isWildcard, ()=>({
-        /**
-     * Since value is '*', we don't need to transform it
-     */ transform: fp.identity,
-        /**
-     * '*' isn't a key/value structure, so regardless
-     *  of the given key, it returns the data ('*')
-     */ 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: fp.constant([
-            ''
-        ]),
-        /**
-     * Removing '*' means setting it to undefined, regardless of the given key
-     */ remove: fp.constant(undefined)
-    }))// Parse string values
-.parse(fp.isString, ()=>{
-    const tokenize = fp.split('.');
-    const recompose = fp.join('.');
-    return {
-        transform: fp.trim,
-        remove (key, data) {
-            const [root] = tokenize(data);
-            return root === key ? undefined : data;
-        },
-        set (key, value, data) {
-            const [root] = tokenize(data);
-            if (root !== key) {
-                return data;
-            }
-            return fp.isNil(value) || fp.isEmpty(value) ? root : `${root}.${value}`;
-        },
-        keys (data) {
-            const v = fp.first(tokenize(data));
-            return v ? [
-                v
-            ] : [];
-        },
-        get (key, data) {
-            const [root, ...rest] = tokenize(data);
-            return key === root ? recompose(rest) : undefined;
-        }
-    };
-})// Parse object values
-.parse(isObj, ()=>({
-        transform: fp.cloneDeep,
-        remove (key, data) {
-            // eslint-disable-next-line no-unused-vars
-            const { [key]: ignored, ...rest } = data;
-            return rest;
-        },
-        set (key, value, data) {
-            return {
-                ...data,
-                [key]: value
-            };
-        },
-        keys (data) {
-            return Object.keys(data);
-        },
-        get (key, data) {
-            return data[key];
-        }
-    })).ignore(({ key, attribute })=>{
-    // we don't want to recurse using traversePopulate and instead let
-    // the visitors recurse with the appropriate traversal (sort, filters, etc...)
-    return [
-        'sort',
-        'filters',
-        'fields'
-    ].includes(key) && !attribute;
-}).on(// Handle recursion on populate."populate"
-isKeyword('populate'), async ({ key, visitor, path, value, schema, getModel, attribute }, { set, recurse })=>{
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const newValue = await recurse(visitor, {
-        schema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-}).on(isKeyword('on'), async ({ key, visitor, path, value, getModel, parent }, { set, recurse })=>{
-    const newOn = {};
-    if (!isObj(value)) {
-        return;
-    }
-    for (const [uid, subPopulate] of Object.entries(value)){
-        const model = getModel(uid);
-        const newPath = {
-            ...path,
-            raw: `${path.raw}[${uid}]`
-        };
-        newOn[uid] = await recurse(visitor, {
-            schema: model,
-            path: newPath,
-            getModel,
-            parent
-        }, subPopulate);
-    }
-    set(key, newOn);
-})// Handle populate on relation
-.onRelation(async ({ key, value, attribute, visitor, path, schema, getModel }, { set, recurse })=>{
-    if (fp.isNil(value)) {
-        return;
-    }
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    if (isMorphToRelationalAttribute(attribute)) {
-        // Don't traverse values that cannot be parsed
-        if (!fp.isObject(value) || !('on' in value && fp.isObject(value?.on))) {
-            return;
-        }
-        // If there is a populate fragment defined, traverse it
-        const newValue = await recurse(visitor, {
-            schema,
-            path,
-            getModel,
-            parent
-        }, {
-            on: value?.on
-        });
-        set(key, newValue);
-        return;
-    }
-    const targetSchemaUID = attribute.target;
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-})// Handle populate on media
-.onMedia(async ({ key, path, schema, attribute, visitor, value, getModel }, { recurse, set })=>{
-    if (fp.isNil(value)) {
-        return;
-    }
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const targetSchemaUID = 'plugin::upload.file';
-    const targetSchema = getModel(targetSchemaUID);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-})// Handle populate on components
-.onComponent(async ({ key, value, schema, visitor, path, attribute, getModel }, { recurse, set })=>{
-    if (fp.isNil(value)) {
-        return;
-    }
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    const targetSchema = getModel(attribute.component);
-    const newValue = await recurse(visitor, {
-        schema: targetSchema,
-        path,
-        getModel,
-        parent
-    }, value);
-    set(key, newValue);
-})// Handle populate on dynamic zones
-.onDynamicZone(async ({ key, value, schema, visitor, path, attribute, getModel }, { set, recurse })=>{
-    if (fp.isNil(value) || !fp.isObject(value)) {
-        return;
-    }
-    const parent = {
-        key,
-        path,
-        schema,
-        attribute
-    };
-    // Handle fragment syntax
-    if ('on' in value && value.on) {
-        const newOn = await recurse(visitor, {
-            schema,
-            path,
-            getModel,
-            parent
-        }, {
-            on: value.on
-        });
-        set(key, newOn);
-    }
-});
-var traverseQueryPopulate = fp.curry(populate.traverse);
-const objectPopulateToPaths = (input)=>{
-    const paths = [];
-    function traverse(currentObj, parentPath) {
-        for (const [key, value] of Object.entries(currentObj)){
-            const currentPath = parentPath ? `${parentPath}.${key}` : key;
-            if (value === true) {
-                paths.push(currentPath);
-            } else {
-                traverse(value.populate, currentPath);
-            }
-        }
-    }
-    traverse(input, '');
-    return paths;
-};
-const pathsToObjectPopulate = (input)=>{
-    const result = {};
-    function traverse(object, keys) {
-        const [first, ...rest] = keys;
-        if (rest.length === 0) {
-            object[first] = true;
-        } else {
-            if (!object[first] || typeof object[first] === 'boolean') {
-                object[first] = {
-                    populate: {}
-                };
-            }
-            traverse(object[first].populate, rest);
-        }
-    }
-    input.forEach((clause)=>traverse(result, clause.split('.')));
-    return result;
-};
-
-const isStringArray = (value)=>{
-    return fp.isArray(value) && value.every(fp.isString);
-};
-const fields = traverseFactory()// Intercept array of strings
-// e.g. fields=['title', 'description']
-.intercept(isStringArray, async (visitor, options, fields, { recurse })=>{
-    return Promise.all(fields.map((field)=>recurse(visitor, options, field)));
-})// Intercept comma separated fields (as string)
-// e.g. fields='title,description'
-.intercept((value)=>fp.isString(value) && value.includes(','), (visitor, options, fields, { recurse })=>{
-    return Promise.all(fields.split(',').map((field)=>recurse(visitor, options, field)));
-})// Return wildcards as is
-.intercept((value)=>fp.eq('*', value), fp.constant('*'))// Parse string values
-// Since we're parsing strings only, each value should be an attribute name (and it's value, undefined),
-// thus it shouldn't be possible to set a new value, and get should return the whole data if key === data
-.parse(fp.isString, ()=>({
-        transform: fp.trim,
-        remove (key, data) {
-            return data === key ? undefined : data;
-        },
-        set (_key, _value, data) {
-            return data;
-        },
-        keys (data) {
-            return [
-                data
-            ];
-        },
-        get (key, data) {
-            return key === data ? data : undefined;
-        }
-    }));
-var traverseQueryFields = fp.curry(fields.traverse);
-
-var index$3 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  traverseQueryFields: traverseQueryFields,
-  traverseQueryFilters: traverseQueryFilters,
-  traverseQueryPopulate: traverseQueryPopulate,
-  traverseQuerySort: traverseQuerySort
-});
-
-const { ID_ATTRIBUTE: ID_ATTRIBUTE$2, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$2 } = constants$1;
-const sanitizePasswords = (ctx)=>async (entity)=>{
-        if (!ctx.schema) {
-            throw new Error('Missing schema in sanitizePasswords');
-        }
-        return traverseEntity$1(visitor$8, ctx, entity);
-    };
-const defaultSanitizeOutput = async (ctx, entity)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultSanitizeOutput');
-    }
-    return traverseEntity$1((...args)=>{
-        visitor$8(...args);
-        visitor$7(...args);
-    }, ctx, entity);
-};
-const defaultSanitizeFilters = fp.curry((ctx, filters)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultSanitizeFilters');
-    }
-    return pipe(// Remove keys that are not attributes or valid operators
-    traverseQueryFilters(({ key, attribute }, { remove })=>{
-        const isAttribute = !!attribute;
-        // ID is not an attribute per se, so we need to make
-        // an extra check to ensure we're not checking it
-        if ([
-            ID_ATTRIBUTE$2,
-            DOC_ID_ATTRIBUTE$2
-        ].includes(key)) {
-            return;
-        }
-        if (!isAttribute && !isOperator(key)) {
-            remove(key);
-        }
-    }, ctx), // Remove dynamic zones from filters
-    traverseQueryFilters(visitor$5, ctx), // Remove morpTo relations from filters
-    traverseQueryFilters(visitor$6, ctx), // Remove passwords from filters
-    traverseQueryFilters(visitor$8, ctx), // Remove private from filters
-    traverseQueryFilters(visitor$7, ctx), // Remove empty objects
-    traverseQueryFilters(({ key, value }, { remove })=>{
-        if (fp.isObject(value) && fp.isEmpty(value)) {
-            remove(key);
-        }
-    }, ctx))(filters);
-});
-const defaultSanitizeSort = fp.curry((ctx, sort)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultSanitizeSort');
-    }
-    return pipe(// Remove non attribute keys
-    traverseQuerySort(({ key, attribute }, { remove })=>{
-        // ID is not an attribute per se, so we need to make
-        // an extra check to ensure we're not checking it
-        if ([
-            ID_ATTRIBUTE$2,
-            DOC_ID_ATTRIBUTE$2
-        ].includes(key)) {
-            return;
-        }
-        if (!attribute) {
-            remove(key);
-        }
-    }, ctx), // Remove dynamic zones from sort
-    traverseQuerySort(visitor$5, ctx), // Remove morpTo relations from sort
-    traverseQuerySort(visitor$6, ctx), // Remove private from sort
-    traverseQuerySort(visitor$7, ctx), // Remove passwords from filters
-    traverseQuerySort(visitor$8, ctx), // Remove keys for empty non-scalar values
-    traverseQuerySort(({ key, attribute, value }, { remove })=>{
-        // ID is not an attribute per se, so we need to make
-        // an extra check to ensure we're not removing it
-        if ([
-            ID_ATTRIBUTE$2,
-            DOC_ID_ATTRIBUTE$2
-        ].includes(key)) {
-            return;
-        }
-        if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
-            remove(key);
-        }
-    }, ctx))(sort);
-});
-const defaultSanitizeFields = fp.curry((ctx, fields)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultSanitizeFields');
-    }
-    return pipe(// Only keep scalar attributes
-    traverseQueryFields(({ key, attribute }, { remove })=>{
-        // ID is not an attribute per se, so we need to make
-        // an extra check to ensure we're not checking it
-        if ([
-            ID_ATTRIBUTE$2,
-            DOC_ID_ATTRIBUTE$2
-        ].includes(key)) {
-            return;
-        }
-        if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
-            remove(key);
-        }
-    }, ctx), // Remove private fields
-    traverseQueryFields(visitor$7, ctx), // Remove password fields
-    traverseQueryFields(visitor$8, ctx), // Remove nil values from fields array
-    (value)=>fp.isArray(value) ? value.filter((field)=>!fp.isNil(field)) : value)(fields);
-});
-const defaultSanitizePopulate = fp.curry((ctx, populate)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultSanitizePopulate');
-    }
-    return pipe(traverseQueryPopulate(visitor$4, ctx), traverseQueryPopulate(async ({ key, value, schema, attribute, getModel, path }, { set })=>{
-        if (attribute) {
-            return;
-        }
-        const parent = {
-            key,
-            path,
-            schema,
-            attribute
-        };
-        if (key === 'sort') {
-            set(key, await defaultSanitizeSort({
-                schema,
-                getModel,
-                parent
-            }, value));
-        }
-        if (key === 'filters') {
-            set(key, await defaultSanitizeFilters({
-                schema,
-                getModel,
-                parent
-            }, value));
-        }
-        if (key === 'fields') {
-            set(key, await defaultSanitizeFields({
-                schema,
-                getModel,
-                parent
-            }, value));
-        }
-        if (key === 'populate') {
-            set(key, await defaultSanitizePopulate({
-                schema,
-                getModel,
-                parent
-            }, value));
-        }
-    }, ctx), // Remove private fields
-    traverseQueryPopulate(visitor$7, ctx))(populate);
-});
-
-var sanitizers = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  defaultSanitizeFields: defaultSanitizeFields,
-  defaultSanitizeFilters: defaultSanitizeFilters,
-  defaultSanitizeOutput: defaultSanitizeOutput,
-  defaultSanitizePopulate: defaultSanitizePopulate,
-  defaultSanitizeSort: defaultSanitizeSort,
-  sanitizePasswords: sanitizePasswords
-});
-
-const createAPISanitizers = (opts)=>{
-    const { getModel } = opts;
-    const sanitizeInput = (data, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in sanitizeInput');
-        }
-        if (fp.isArray(data)) {
-            return Promise.all(data.map((entry)=>sanitizeInput(entry, schema, {
-                    auth
-                })));
-        }
-        const nonWritableAttributes = getNonWritableAttributes(schema);
-        const transforms = [
-            // Remove first level ID in inputs
-            fp.omit(constants$1.ID_ATTRIBUTE),
-            fp.omit(constants$1.DOC_ID_ATTRIBUTE),
-            // Remove non-writable attributes
-            traverseEntity$1(removeRestrictedFields(nonWritableAttributes), {
-                schema,
-                getModel
-            })
-        ];
-        if (auth) {
-            // Remove restricted relations
-            transforms.push(traverseEntity$1(removeRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        // Apply sanitizers from registry if exists
-        opts?.sanitizers?.input?.forEach((sanitizer)=>transforms.push(sanitizer(schema)));
-        return pipe(...transforms)(data);
-    };
-    const sanitizeOutput = async (data, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in sanitizeOutput');
-        }
-        if (fp.isArray(data)) {
-            const res = new Array(data.length);
-            for(let i = 0; i < data.length; i += 1){
-                res[i] = await sanitizeOutput(data[i], schema, {
-                    auth
-                });
-            }
-            return res;
-        }
-        const transforms = [
-            (data)=>defaultSanitizeOutput({
-                    schema,
-                    getModel
-                }, data)
-        ];
-        if (auth) {
-            transforms.push(traverseEntity$1(removeRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        // Apply sanitizers from registry if exists
-        opts?.sanitizers?.output?.forEach((sanitizer)=>transforms.push(sanitizer(schema)));
-        return pipe(...transforms)(data);
-    };
-    const sanitizeQuery = async (query, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in sanitizeQuery');
-        }
-        const { filters, sort, fields, populate } = query;
-        const sanitizedQuery = fp.cloneDeep(query);
-        if (filters) {
-            Object.assign(sanitizedQuery, {
-                filters: await sanitizeFilters(filters, schema, {
-                    auth
-                })
-            });
-        }
-        if (sort) {
-            Object.assign(sanitizedQuery, {
-                sort: await sanitizeSort(sort, schema, {
-                    auth
-                })
-            });
-        }
-        if (fields) {
-            Object.assign(sanitizedQuery, {
-                fields: await sanitizeFields(fields, schema)
-            });
-        }
-        if (populate) {
-            Object.assign(sanitizedQuery, {
-                populate: await sanitizePopulate(populate, schema)
-            });
-        }
-        return sanitizedQuery;
-    };
-    const sanitizeFilters = (filters, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in sanitizeFilters');
-        }
-        if (fp.isArray(filters)) {
-            return Promise.all(filters.map((filter)=>sanitizeFilters(filter, schema, {
-                    auth
-                })));
-        }
-        const transforms = [
-            defaultSanitizeFilters({
-                schema,
-                getModel
-            })
-        ];
-        if (auth) {
-            transforms.push(traverseQueryFilters(removeRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        return pipe(...transforms)(filters);
-    };
-    const sanitizeSort = (sort, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in sanitizeSort');
-        }
-        const transforms = [
-            defaultSanitizeSort({
-                schema,
-                getModel
-            })
-        ];
-        if (auth) {
-            transforms.push(traverseQuerySort(removeRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        return pipe(...transforms)(sort);
-    };
-    const sanitizeFields = (fields, schema)=>{
-        if (!schema) {
-            throw new Error('Missing schema in sanitizeFields');
-        }
-        const transforms = [
-            defaultSanitizeFields({
-                schema,
-                getModel
-            })
-        ];
-        return pipe(...transforms)(fields);
-    };
-    const sanitizePopulate = (populate, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in sanitizePopulate');
-        }
-        const transforms = [
-            defaultSanitizePopulate({
-                schema,
-                getModel
-            })
-        ];
-        if (auth) {
-            transforms.push(traverseQueryPopulate(removeRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        return pipe(...transforms)(populate);
-    };
-    return {
-        input: sanitizeInput,
-        output: sanitizeOutput,
-        query: sanitizeQuery,
-        filters: sanitizeFilters,
-        sort: sanitizeSort,
-        fields: sanitizeFields,
-        populate: sanitizePopulate
-    };
-};
-
-var index$2 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createAPISanitizers: createAPISanitizers,
-  sanitizers: sanitizers,
-  visitors: index$4
-});
-
-// lodash/fp curry does not handle async functions properly, and creates very "ugly" types,
-// so we will use our own version to ensure curried functions are typed correctly
-// TODO: Export this from root @strapi/utils so we don't have copies of it between packages
-const throwInvalidKey = ({ key, path })=>{
-    const msg = path && path !== key ? `Invalid key ${key} at ${path}` : `Invalid key ${key}`;
-    throw new ValidationError(msg, {
-        key,
-        path
-    });
-};
-const asyncCurry = (fn)=>{
-    const curried = (...args)=>{
-        if (args.length >= fn.length) {
-            return fn(...args);
-        }
-        return (...moreArgs)=>curried(...args, ...moreArgs);
-    };
-    return curried;
-};
-
-const visitor$3 = ({ key, attribute, path })=>{
-    if (attribute?.type === 'password') {
-        throwInvalidKey({
-            key,
-            path: path.attribute
-        });
-    }
-};
-
-const visitor$2 = ({ schema, key, attribute, path })=>{
-    if (!attribute) {
-        return;
-    }
-    const isPrivate = attribute.private === true || isPrivateAttribute(schema, key);
-    if (isPrivate) {
-        throwInvalidKey({
-            key,
-            path: path.attribute
-        });
-    }
-};
-
-const ACTIONS_TO_VERIFY = [
-    'find'
-];
-const { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = constants$1;
-var throwRestrictedRelations = ((auth)=>async ({ data, key, attribute, schema, path })=>{
-        if (!attribute) {
-            return;
-        }
-        const isRelation = attribute.type === 'relation';
-        if (!isRelation) {
-            return;
-        }
-        const handleMorphRelation = async ()=>{
-            const elements = data[key];
-            if ('connect' in elements || 'set' in elements || 'disconnect' in elements || 'options' in elements) {
-                await handleMorphElements(elements.connect || []);
-                await handleMorphElements(elements.set || []);
-                await handleMorphElements(elements.disconnect || []);
-                // TODO: this should technically be in its own visitor to check morph options, but for now we'll handle it here
-                if ('options' in elements) {
-                    if (elements.options === null || elements.options === undefined) {
-                        return;
-                    }
-                    if (typeof elements.options !== 'object') {
-                        throwInvalidKey({
-                            key,
-                            path: path.attribute
-                        });
-                    }
-                    const optionKeys = Object.keys(elements.options);
-                    // Validate each key based on its validator function
-                    for (const key of optionKeys){
-                        if (!(key in VALID_RELATION_ORDERING_KEYS)) {
-                            throwInvalidKey({
-                                key,
-                                path: path.attribute
-                            });
-                        }
-                        if (!VALID_RELATION_ORDERING_KEYS[key](elements.options[key])) {
-                            throwInvalidKey({
-                                key,
-                                path: path.attribute
-                            });
-                        }
-                    }
-                }
-            } else {
-                await handleMorphElements(elements);
-            }
-        };
-        const handleMorphElements = async (elements)=>{
-            if (!fp.isArray(elements)) {
-                throwInvalidKey({
-                    key,
-                    path: path.attribute
-                });
-            }
-            for (const element of elements){
-                if (!fp.isObject(element) || !('__type' in element)) {
-                    throwInvalidKey({
-                        key,
-                        path: path.attribute
-                    });
-                }
-                const scopes = ACTIONS_TO_VERIFY.map((action)=>`${element.__type}.${action}`);
-                const isAllowed = await hasAccessToSomeScopes(scopes, auth);
-                if (!isAllowed) {
-                    throwInvalidKey({
-                        key,
-                        path: path.attribute
-                    });
-                }
-            }
-        };
-        const handleRegularRelation = async ()=>{
-            const scopes = ACTIONS_TO_VERIFY.map((action)=>`${attribute.target}.${action}`);
-            const isAllowed = await hasAccessToSomeScopes(scopes, auth);
-            // If the authenticated user don't have access to any of the scopes
-            if (!isAllowed) {
-                throwInvalidKey({
-                    key,
-                    path: path.attribute
-                });
-            }
-        };
-        const isCreatorRelation = [
-            CREATED_BY_ATTRIBUTE,
-            UPDATED_BY_ATTRIBUTE
-        ].includes(key);
-        // Polymorphic relations
-        if (isMorphToRelationalAttribute(attribute)) {
-            await handleMorphRelation();
-            return;
-        }
-        // Creator relations
-        if (isCreatorRelation && schema.options?.populateCreatorFields) {
-            // do nothing
-            return;
-        }
-        // Regular relations
-        await handleRegularRelation();
-    });
-const hasAccessToSomeScopes = async (scopes, auth)=>{
-    for (const scope of scopes){
-        try {
-            await strapi.auth.verify(auth, {
-                scope
-            });
-            return true;
-        } catch  {
-            continue;
-        }
-    }
-    return false;
-};
-
-const visitor$1 = ({ key, attribute, path })=>{
-    if (isMorphToRelationalAttribute(attribute)) {
-        throwInvalidKey({
-            key,
-            path: path.attribute
-        });
-    }
-};
-
-const visitor = ({ key, attribute, path })=>{
-    if (isDynamicZoneAttribute(attribute)) {
-        throwInvalidKey({
-            key,
-            path: path.attribute
-        });
-    }
-};
-
-var throwDisallowedFields = ((allowedFields = null)=>({ key, path: { attribute: path } })=>{
-        // All fields are allowed
-        if (allowedFields === null) {
-            return;
-        }
-        // Throw on invalid formats
-        if (!(fp.isArray(allowedFields) && allowedFields.every(fp.isString))) {
-            throw new TypeError(`Expected array of strings for allowedFields but got "${typeof allowedFields}"`);
-        }
-        if (fp.isNil(path)) {
-            return;
-        }
-        const containedPaths = getContainedPaths(path);
-        /**
-     * Tells if the current path should be kept or not based
-     * on the success of the check functions for any of the allowed paths.
-     *
-     * The check functions are defined as follow:
-     *
-     * `containedPaths.includes(p)`
-     * @example
-     * ```js
-     * const path = 'foo.bar.field';
-     * const p = 'foo.bar';
-     * // it should match
-     *
-     * const path = 'foo.bar.field';
-     * const p = 'bar.foo';
-     * // it shouldn't match
-     *
-     * const path = 'foo.bar';
-     * const p = 'foo.bar.field';
-     * // it should match but isn't handled by this check
-     * ```
-     *
-     * `p.startsWith(`${path}.`)`
-     * @example
-     * ```js
-     * const path = 'foo.bar';
-     * const p = 'foo.bar.field';
-     * // it should match
-     *
-     * const path = 'foo.bar.field';
-     * const p = 'bar.foo';
-     * // it shouldn't match
-     *
-     * const path = 'foo.bar.field';
-     * const p = 'foo.bar';
-     * // it should match but isn't handled by this check
-     * ```
-     */ const isPathAllowed = allowedFields.some((p)=>containedPaths.includes(p) || p.startsWith(`${path}.`));
-        if (isPathAllowed) {
-            return;
-        }
-        // throw otherwise
-        throwInvalidKey({
-            key,
-            path
-        });
-    });
-/**
- * Retrieve the list of allowed paths based on the given path
- *
- * @example
- * ```js
- * const containedPaths = getContainedPaths('foo');
- * // ['foo']
- *
- *  * const containedPaths = getContainedPaths('foo.bar');
- * // ['foo', 'foo.bar']
- *
- *  * const containedPaths = getContainedPaths('foo.bar.field');
- * // ['foo', 'foo.bar', 'foo.bar.field']
- * ```
- */ const getContainedPaths = (path)=>{
-    const parts = fp.toPath(path);
-    return parts.reduce((acc, value, index, list)=>{
-        return [
-            ...acc,
-            list.slice(0, index + 1).join('.')
-        ];
-    }, []);
-};
-
-var throwRestrictedFields = ((restrictedFields = null)=>({ key, path: { attribute: path } })=>{
-        // all fields
-        if (restrictedFields === null) {
-            throwInvalidKey({
-                key,
-                path
-            });
-        }
-        // Throw on invalid formats
-        if (!(fp.isArray(restrictedFields) && restrictedFields.every(fp.isString))) {
-            throw new TypeError(`Expected array of strings for restrictedFields but got "${typeof restrictedFields}"`);
-        }
-        // if an exact match was found
-        if (restrictedFields.includes(path)) {
-            throwInvalidKey({
-                key,
-                path
-            });
-        }
-        // nested matches
-        const isRestrictedNested = restrictedFields.some((allowedPath)=>path?.toString().startsWith(`${allowedPath}.`));
-        if (isRestrictedNested) {
-            throwInvalidKey({
-                key,
-                path
-            });
-        }
-    });
-
-// TODO these should all be centralized somewhere instead of maintaining a list
-const ID_FIELDS = [
-    constants$1.DOC_ID_ATTRIBUTE,
-    constants$1.DOC_ID_ATTRIBUTE
-];
-const ALLOWED_ROOT_LEVEL_FIELDS = [
-    ...ID_FIELDS
-];
-const MORPH_TO_ALLOWED_FIELDS = [
-    '__type'
-];
-const DYNAMIC_ZONE_ALLOWED_FIELDS = [
-    '__component'
-];
-const RELATION_REORDERING_FIELDS = [
-    'connect',
-    'disconnect',
-    'set',
-    'options'
-];
-const throwUnrecognizedFields = ({ key, attribute, path, schema, parent })=>{
-    // We only look at properties that are not attributes
-    if (attribute) {
-        return;
-    }
-    // At root level (path.attribute === null), only accept allowed fields
-    if (path.attribute === null) {
-        if (ALLOWED_ROOT_LEVEL_FIELDS.includes(key)) {
-            return;
-        }
-        return throwInvalidKey({
-            key,
-            path: attribute
-        });
-    }
-    // allow special morphTo keys
-    if (isMorphToRelationalAttribute(parent?.attribute) && MORPH_TO_ALLOWED_FIELDS.includes(key)) {
-        return;
-    }
-    // allow special dz keys
-    if (isComponentSchema(schema) && isDynamicZoneAttribute(parent?.attribute) && DYNAMIC_ZONE_ALLOWED_FIELDS.includes(key)) {
-        return;
-    }
-    // allow special relation reordering keys in manyToX and XtoMany relations
-    if (hasRelationReordering(parent?.attribute) && RELATION_REORDERING_FIELDS.includes(key)) {
-        return;
-    }
-    // allow id fields where it is needed for setting a relational id rather than trying to create with a given id
-    const canUseID = isRelationalAttribute(parent?.attribute) || isMediaAttribute(parent?.attribute);
-    if (canUseID && !ID_FIELDS.includes(key)) {
-        return;
-    }
-    // if we couldn't find any reason for it to be here, throw
-    throwInvalidKey({
-        key,
-        path: attribute
-    });
-};
-
-var index$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  throwDisallowedFields: throwDisallowedFields,
-  throwDynamicZones: visitor,
-  throwMorphToRelations: visitor$1,
-  throwPassword: visitor$3,
-  throwPrivate: visitor$2,
-  throwRestrictedFields: throwRestrictedFields,
-  throwRestrictedRelations: throwRestrictedRelations,
-  throwUnrecognizedFields: throwUnrecognizedFields
-});
-
-const { ID_ATTRIBUTE: ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE: DOC_ID_ATTRIBUTE$1 } = constants$1;
-const FILTER_TRAVERSALS = [
-    'nonAttributesOperators',
-    'dynamicZones',
-    'morphRelations',
-    'passwords',
-    'private'
-];
-const validateFilters = asyncCurry(async (ctx, filters, include)=>{
-    // TODO: schema checks should check that it is a valid schema with yup
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultValidateFilters');
-    }
-    // Build the list of functions conditionally
-    const functionsToApply = [];
-    // keys that are not attributes or valid operators
-    if (include.includes('nonAttributesOperators')) {
-        functionsToApply.push(traverseQueryFilters(({ key, attribute, path })=>{
-            // ID is not an attribute per se, so we need to make
-            // an extra check to ensure we're not removing it
-            if ([
-                ID_ATTRIBUTE$1,
-                DOC_ID_ATTRIBUTE$1
-            ].includes(key)) {
-                return;
-            }
-            const isAttribute = !!attribute;
-            if (!isAttribute && !isOperator(key)) {
-                throwInvalidKey({
-                    key,
-                    path: path.attribute
-                });
-            }
-        }, ctx));
-    }
-    if (include.includes('dynamicZones')) {
-        functionsToApply.push(traverseQueryFilters(visitor, ctx));
-    }
-    if (include.includes('morphRelations')) {
-        functionsToApply.push(traverseQueryFilters(visitor$1, ctx));
-    }
-    if (include.includes('passwords')) {
-        functionsToApply.push(traverseQueryFilters(visitor$3, ctx));
-    }
-    if (include.includes('private')) {
-        functionsToApply.push(traverseQueryFilters(visitor$2, ctx));
-    }
-    // Return directly if no validation functions are provided
-    if (functionsToApply.length === 0) {
-        return filters;
-    }
-    return pipe(...functionsToApply)(filters);
-});
-const defaultValidateFilters = asyncCurry(async (ctx, filters)=>{
-    return validateFilters(ctx, filters, FILTER_TRAVERSALS);
-});
-const SORT_TRAVERSALS = [
-    'nonAttributesOperators',
-    'dynamicZones',
-    'morphRelations',
-    'passwords',
-    'private',
-    'nonScalarEmptyKeys'
-];
-const validateSort = asyncCurry(async (ctx, sort, include)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultValidateSort');
-    }
-    // Build the list of functions conditionally based on the include array
-    const functionsToApply = [];
-    // Validate non attribute keys
-    if (include.includes('nonAttributesOperators')) {
-        functionsToApply.push(traverseQuerySort(({ key, attribute, path })=>{
-            // ID is not an attribute per se, so we need to make
-            // an extra check to ensure we're not removing it
-            if ([
-                ID_ATTRIBUTE$1,
-                DOC_ID_ATTRIBUTE$1
-            ].includes(key)) {
-                return;
-            }
-            if (!attribute) {
-                throwInvalidKey({
-                    key,
-                    path: path.attribute
-                });
-            }
-        }, ctx));
-    }
-    // Validate dynamic zones from sort
-    if (include.includes('dynamicZones')) {
-        functionsToApply.push(traverseQuerySort(visitor, ctx));
-    }
-    // Validate morphTo relations from sort
-    if (include.includes('morphRelations')) {
-        functionsToApply.push(traverseQuerySort(visitor$1, ctx));
-    }
-    // Validate passwords from sort
-    if (include.includes('passwords')) {
-        functionsToApply.push(traverseQuerySort(visitor$3, ctx));
-    }
-    // Validate private from sort
-    if (include.includes('private')) {
-        functionsToApply.push(traverseQuerySort(visitor$2, ctx));
-    }
-    // Validate non-scalar empty keys
-    if (include.includes('nonScalarEmptyKeys')) {
-        functionsToApply.push(traverseQuerySort(({ key, attribute, value, path })=>{
-            // ID is not an attribute per se, so we need to make
-            // an extra check to ensure we're not removing it
-            if ([
-                ID_ATTRIBUTE$1,
-                DOC_ID_ATTRIBUTE$1
-            ].includes(key)) {
-                return;
-            }
-            if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
-                throwInvalidKey({
-                    key,
-                    path: path.attribute
-                });
-            }
-        }, ctx));
-    }
-    // Return directly if no validation functions are provided
-    if (functionsToApply.length === 0) {
-        return sort;
-    }
-    return pipe(...functionsToApply)(sort);
-});
-const defaultValidateSort = asyncCurry(async (ctx, sort)=>{
-    return validateSort(ctx, sort, SORT_TRAVERSALS);
-});
-const FIELDS_TRAVERSALS = [
-    'scalarAttributes',
-    'privateFields',
-    'passwordFields'
-];
-const validateFields = asyncCurry(async (ctx, fields, include)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultValidateFields');
-    }
-    // Build the list of functions conditionally based on the include array
-    const functionsToApply = [];
-    // Only allow scalar attributes
-    if (include.includes('scalarAttributes')) {
-        functionsToApply.push(traverseQueryFields(({ key, attribute, path })=>{
-            // ID is not an attribute per se, so we need to make
-            // an extra check to ensure we're not throwing because of it
-            if ([
-                ID_ATTRIBUTE$1,
-                DOC_ID_ATTRIBUTE$1
-            ].includes(key)) {
-                return;
-            }
-            if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
-                throwInvalidKey({
-                    key,
-                    path: path.attribute
-                });
-            }
-        }, ctx));
-    }
-    // Private fields
-    if (include.includes('privateFields')) {
-        functionsToApply.push(traverseQueryFields(visitor$2, ctx));
-    }
-    // Password fields
-    if (include.includes('passwordFields')) {
-        functionsToApply.push(traverseQueryFields(visitor$3, ctx));
-    }
-    // Return directly if no validation functions are provided
-    if (functionsToApply.length === 0) {
-        return fields;
-    }
-    return pipe(...functionsToApply)(fields);
-});
-const defaultValidateFields = asyncCurry(async (ctx, fields)=>{
-    return validateFields(ctx, fields, FIELDS_TRAVERSALS);
-});
-const POPULATE_TRAVERSALS = [
-    'nonAttributesOperators',
-    'private'
-];
-const validatePopulate = asyncCurry(async (ctx, populate, includes)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultValidatePopulate');
-    }
-    // Build the list of functions conditionally based on the include array
-    const functionsToApply = [];
-    // Always include the main traversal function
-    functionsToApply.push(traverseQueryPopulate(async ({ key, path, value, schema, attribute, getModel, parent }, { set })=>{
-        /**
-           * NOTE: The parent check is done to support "filters" (and the rest of keys) as valid attribute names.
-           *
-           * The parent will not be an attribute when its a "populate" / "filters" / "sort" ... key.
-           * Only in those scenarios the node will be an attribute.
-           */ if (!parent?.attribute && attribute) {
-            const isPopulatableAttribute = [
-                'relation',
-                'dynamiczone',
-                'component',
-                'media'
-            ].includes(attribute.type);
-            // Throw on non-populate attributes
-            if (!isPopulatableAttribute) {
-                throwInvalidKey({
-                    key,
-                    path: path.raw
-                });
-            }
-            // Valid populatable attribute, so return
-            return;
-        }
-        // If we're looking at a populate fragment, ensure its target is valid
-        if (key === 'on') {
-            // Populate fragment should always be an object
-            if (!fp.isObject(value)) {
-                return throwInvalidKey({
-                    key,
-                    path: path.raw
-                });
-            }
-            const targets = Object.keys(value);
-            for (const target of targets){
-                const model = getModel(target);
-                // If a target is invalid (no matching model), then raise an error
-                if (!model) {
-                    throwInvalidKey({
-                        key: target,
-                        path: `${path.raw}.${target}`
-                    });
-                }
-            }
-            // If the fragment's target is fine, then let it pass
-            return;
-        }
-        // Ignore plain wildcards
-        if (key === '' && value === '*') {
-            return;
-        }
-        // Ensure count is a boolean
-        if (key === 'count') {
-            try {
-                parseType({
-                    type: 'boolean',
-                    value
-                });
-                return;
-            } catch  {
-                throwInvalidKey({
-                    key,
-                    path: path.attribute
-                });
-            }
-        }
-        // Allowed boolean-like keywords should be ignored
-        try {
-            parseType({
-                type: 'boolean',
-                value: key
-            });
-            // Key is an allowed boolean-like keyword, skipping validation...
-            return;
-        } catch  {
-        // Continue, because it's not a boolean-like
-        }
-        // Handle nested `sort` validation with custom or default traversals
-        if (key === 'sort') {
-            set(key, await validateSort({
-                schema,
-                getModel
-            }, value, includes?.sort || SORT_TRAVERSALS));
-            return;
-        }
-        // Handle nested `filters` validation with custom or default traversals
-        if (key === 'filters') {
-            set(key, await validateFilters({
-                schema,
-                getModel
-            }, value, includes?.filters || FILTER_TRAVERSALS));
-            return;
-        }
-        // Handle nested `fields` validation with custom or default traversals
-        if (key === 'fields') {
-            set(key, await validateFields({
-                schema,
-                getModel
-            }, value, includes?.fields || FIELDS_TRAVERSALS));
-            return;
-        }
-        // Handle recursive nested `populate` validation with the same include object
-        if (key === 'populate') {
-            set(key, await validatePopulate({
-                schema,
-                getModel,
-                parent: {
-                    key,
-                    path,
-                    schema,
-                    attribute
-                },
-                path
-            }, value, includes // pass down the same includes object
-            ));
-            return;
-        }
-        // Throw an error if non-attribute operators are included in the populate array
-        if (includes?.populate?.includes('nonAttributesOperators')) {
-            throwInvalidKey({
-                key,
-                path: path.attribute
-            });
-        }
-    }, ctx));
-    // Conditionally traverse for private fields only if 'private' is included
-    if (includes?.populate?.includes('private')) {
-        functionsToApply.push(traverseQueryPopulate(visitor$2, ctx));
-    }
-    // Return directly if no validation functions are provided
-    if (functionsToApply.length === 0) {
-        return populate;
-    }
-    return pipe(...functionsToApply)(populate);
-});
-const defaultValidatePopulate = asyncCurry(async (ctx, populate)=>{
-    if (!ctx.schema) {
-        throw new Error('Missing schema in defaultValidatePopulate');
-    }
-    // Call validatePopulate and include all validations by passing in full traversal arrays
-    return validatePopulate(ctx, populate, {
-        filters: FILTER_TRAVERSALS,
-        sort: SORT_TRAVERSALS,
-        fields: FIELDS_TRAVERSALS,
-        populate: POPULATE_TRAVERSALS
-    });
-});
-
-var validators = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  FIELDS_TRAVERSALS: FIELDS_TRAVERSALS,
-  FILTER_TRAVERSALS: FILTER_TRAVERSALS,
-  POPULATE_TRAVERSALS: POPULATE_TRAVERSALS,
-  SORT_TRAVERSALS: SORT_TRAVERSALS,
-  defaultValidateFields: defaultValidateFields,
-  defaultValidateFilters: defaultValidateFilters,
-  defaultValidatePopulate: defaultValidatePopulate,
-  defaultValidateSort: defaultValidateSort,
-  validateFields: validateFields,
-  validateFilters: validateFilters,
-  validatePopulate: validatePopulate,
-  validateSort: validateSort
-});
-
-const { ID_ATTRIBUTE, DOC_ID_ATTRIBUTE } = constants$1;
-const createAPIValidators = (opts)=>{
-    const { getModel } = opts || {};
-    const validateInput = async (data, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in validateInput');
-        }
-        if (fp.isArray(data)) {
-            await Promise.all(data.map((entry)=>validateInput(entry, schema, {
-                    auth
-                })));
-            return;
-        }
-        const nonWritableAttributes = getNonWritableAttributes(schema);
-        const transforms = [
-            (data)=>{
-                if (fp.isObject(data)) {
-                    if (ID_ATTRIBUTE in data) {
-                        throwInvalidKey({
-                            key: ID_ATTRIBUTE
-                        });
-                    }
-                    if (DOC_ID_ATTRIBUTE in data) {
-                        throwInvalidKey({
-                            key: DOC_ID_ATTRIBUTE
-                        });
-                    }
-                }
-                return data;
-            },
-            // non-writable attributes
-            traverseEntity$1(throwRestrictedFields(nonWritableAttributes), {
-                schema,
-                getModel
-            }),
-            // unrecognized attributes
-            traverseEntity$1(throwUnrecognizedFields, {
-                schema,
-                getModel
-            })
-        ];
-        if (auth) {
-            // restricted relations
-            transforms.push(traverseEntity$1(throwRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        // Apply validators from registry if exists
-        opts?.validators?.input?.forEach((validator)=>transforms.push(validator(schema)));
-        try {
-            await pipe(...transforms)(data);
-        } catch (e) {
-            if (e instanceof ValidationError) {
-                e.details.source = 'body';
-            }
-            throw e;
-        }
-    };
-    const validateQuery = async (query, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in validateQuery');
-        }
-        const { filters, sort, fields, populate } = query;
-        if (filters) {
-            await validateFilters(filters, schema, {
-                auth
-            });
-        }
-        if (sort) {
-            await validateSort(sort, schema, {
-                auth
-            });
-        }
-        if (fields) {
-            await validateFields(fields, schema);
-        }
-        // a wildcard is always valid; its conversion will be handled by the entity service and can be optimized with sanitizer
-        if (populate && populate !== '*') {
-            await validatePopulate(populate, schema);
-        }
-    };
-    const validateFilters = async (filters, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in validateFilters');
-        }
-        if (fp.isArray(filters)) {
-            await Promise.all(filters.map((filter)=>validateFilters(filter, schema, {
-                    auth
-                })));
-            return;
-        }
-        const transforms = [
-            defaultValidateFilters({
-                schema,
-                getModel
-            })
-        ];
-        if (auth) {
-            transforms.push(traverseQueryFilters(throwRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        try {
-            await pipe(...transforms)(filters);
-        } catch (e) {
-            if (e instanceof ValidationError) {
-                e.details.source = 'query';
-                e.details.param = 'filters';
-            }
-            throw e;
-        }
-    };
-    const validateSort = async (sort, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in validateSort');
-        }
-        const transforms = [
-            defaultValidateSort({
-                schema,
-                getModel
-            })
-        ];
-        if (auth) {
-            transforms.push(traverseQuerySort(throwRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        try {
-            await pipe(...transforms)(sort);
-        } catch (e) {
-            if (e instanceof ValidationError) {
-                e.details.source = 'query';
-                e.details.param = 'sort';
-            }
-            throw e;
-        }
-    };
-    const validateFields = async (fields, schema)=>{
-        if (!schema) {
-            throw new Error('Missing schema in validateFields');
-        }
-        const transforms = [
-            defaultValidateFields({
-                schema,
-                getModel
-            })
-        ];
-        try {
-            await pipe(...transforms)(fields);
-        } catch (e) {
-            if (e instanceof ValidationError) {
-                e.details.source = 'query';
-                e.details.param = 'fields';
-            }
-            throw e;
-        }
-    };
-    const validatePopulate = async (populate, schema, { auth } = {})=>{
-        if (!schema) {
-            throw new Error('Missing schema in sanitizePopulate');
-        }
-        const transforms = [
-            defaultValidatePopulate({
-                schema,
-                getModel
-            })
-        ];
-        if (auth) {
-            transforms.push(traverseQueryPopulate(throwRestrictedRelations(auth), {
-                schema,
-                getModel
-            }));
-        }
-        try {
-            await pipe(...transforms)(populate);
-        } catch (e) {
-            if (e instanceof ValidationError) {
-                e.details.source = 'query';
-                e.details.param = 'populate';
-            }
-            throw e;
-        }
-    };
-    return {
-        input: validateInput,
-        query: validateQuery,
-        filters: validateFilters,
-        sort: validateSort,
-        fields: validateFields,
-        populate: validatePopulate
-    };
-};
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createAPIValidators: createAPIValidators,
-  validators: validators,
-  visitors: index$1
-});
-
-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;
-};
-// Ensure minimum page & pageSize values (page >= 1, pageSize >= 0, start >= 0, limit >= 0)
-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)
-        });
-// Apply maxLimit as the limit when limit is -1
-const withNoLimit = (pagination, maxLimit = -1)=>({
-        ...pagination,
-        limit: pagination.limit === -1 ? maxLimit : pagination.limit
-    });
-const withDefaultPagination = (args, { defaults = {}, maxLimit = -1 } = {})=>{
-    const defaultValues = fp.merge(STRAPI_DEFAULTS, defaults);
-    const usePagePagination = !fp.isNil(args.page) || !fp.isNil(args.pageSize);
-    const useOffsetPagination = !fp.isNil(args.start) || !fp.isNil(args.limit);
-    const ensureValidValues = fp.pipe(ensureMinValues, ensureMaxValues(maxLimit));
-    // If there is no pagination attribute, don't modify the payload
-    if (!usePagePagination && !useOffsetPagination) {
-        return fp.merge(args, ensureValidValues(defaultValues.offset));
-    }
-    // If there is page & offset pagination attributes, throw an error
-    if (usePagePagination && useOffsetPagination) {
-        throw new PaginationError('Cannot use both page & offset pagination in the same query');
-    }
-    const pagination = {
-        start: 0,
-        limit: 0
-    };
-    // Start / Limit
-    if (useOffsetPagination) {
-        const { start, limit } = fp.merge(defaultValues.offset, args);
-        Object.assign(pagination, {
-            start,
-            limit
-        });
-    }
-    // Page / PageSize
-    if (usePagePagination) {
-        const { page, pageSize } = fp.merge(defaultValues.page, {
-            ...args,
-            pageSize: Math.max(1, args.pageSize ?? 0)
-        });
-        Object.assign(pagination, {
-            start: (page - 1) * pageSize,
-            limit: pageSize
-        });
-    }
-    // Handle -1 limit
-    Object.assign(pagination, withNoLimit(pagination, maxLimit));
-    const replacePaginationAttributes = fp.pipe(// Remove pagination attributes
-    fp.omit(paginationAttributes), // Merge the object with the new pagination + ensure minimum & maximum values
-    fp.merge(ensureValidValues(pagination)));
-    return replacePaginationAttributes(args);
-};
-/**
- * Transform pagination information into a paginated response:
- * {
- *    page: number,
- *    pageSize: number,
- *    pageCount: number,
- *    total: number
- * }
- */ const transformPagedPaginationInfo = (paginationInfo, total)=>{
-    if (!fp.isNil(paginationInfo.page)) {
-        const page = paginationInfo.page;
-        const pageSize = paginationInfo.pageSize ?? total;
-        return {
-            page,
-            pageSize,
-            pageCount: pageSize > 0 ? Math.ceil(total / pageSize) : 0,
-            total
-        };
-    }
-    if (!fp.isNil(paginationInfo.start)) {
-        const start = paginationInfo.start;
-        const limit = paginationInfo.limit ?? total;
-        // Start limit to page page size
-        return {
-            page: Math.floor(start / limit) + 1,
-            pageSize: limit,
-            pageCount: limit > 0 ? Math.ceil(total / limit) : 0,
-            total
-        };
-    }
-    // Default pagination
-    return {
-        ...paginationInfo,
-        page: 1,
-        pageSize: 10,
-        pageCount: 1,
-        total
-    };
-};
-/**
- * Transform pagination information into a offset response:
- * {
- *    start: number,
- *    limit: number,
- *    total: number
- * }
- */ const transformOffsetPaginationInfo = (paginationInfo, total)=>{
-    if (!fp.isNil(paginationInfo.page)) {
-        const limit = paginationInfo.pageSize ?? total;
-        const start = (paginationInfo.page - 1) * limit;
-        return {
-            start,
-            limit,
-            total
-        };
-    }
-    if (!fp.isNil(paginationInfo.start)) {
-        const start = paginationInfo.start;
-        const limit = paginationInfo.limit ?? total;
-        // Start limit to page page size
-        return {
-            start,
-            limit,
-            total
-        };
-    }
-    // Default pagination
-    return {
-        ...paginationInfo,
-        start: 0,
-        limit: 10,
-        total
-    };
-};
-
-var pagination = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  transformOffsetPaginationInfo: transformOffsetPaginationInfo,
-  transformPagedPaginationInfo: transformPagedPaginationInfo,
-  withDefaultPagination: withDefaultPagination
-});
-
-const SUPPORTED_PACKAGE_MANAGERS = [
-    'npm',
-    'yarn'
-];
-const DEFAULT_PACKAGE_MANAGER = 'npm';
-const getPreferred = async (pkgPath)=>{
-    const pm = await preferredPM(pkgPath);
-    const hasPackageManager = pm !== undefined;
-    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;
-    }
-    return pm.name;
-};
-const installDependencies = (path, packageManager, options = {})=>{
-    return execa(packageManager, [
-        'install'
-    ], {
-        ...options,
-        cwd: path,
-        stdin: 'ignore'
-    });
-};
-
-var packageManager = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getPreferred: getPreferred,
-  installDependencies: installDependencies
-});
-
-/**
- * Create a strict interpolation RegExp based on the given variables' name
- */ const createStrictInterpolationRegExp = (allowedVariableNames, flags)=>{
-    const oneOfVariables = allowedVariableNames.join('|');
-    // 1. We need to match the delimiters: <%= ... %>
-    // 2. We accept any number of whitespaces characters before and/or after the variable name: \s* ... \s*
-    // 3. We only accept values from the variable list as interpolation variables' name: : (${oneOfVariables})
-    return new RegExp(`<%=\\s*(${oneOfVariables})\\s*%>`, flags);
-};
-/**
- * Create a loose interpolation RegExp to match as many groups as possible
- */ const createLooseInterpolationRegExp = (flags)=>new RegExp(/<%=([\s\S]+?)%>/, flags);
-
-var template = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createLooseInterpolationRegExp: createLooseInterpolationRegExp,
-  createStrictInterpolationRegExp: createStrictInterpolationRegExp
-});
-
-const kbytesToBytes = (kbytes)=>kbytes * 1000;
-const bytesToKbytes = (bytes)=>Math.round(bytes / 1000 * 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(1000))}`, 10);
-    return `${Math.round(bytes / 1000 ** 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();
-    });
-/**
- * Create a writeable Node.js stream that discards received data.
- * Useful for testing, draining a stream of data, etc.
- */ function writableDiscardStream(options) {
-    return new node_stream.Writable({
-        ...options,
-        write (chunk, encding, callback) {
-            setImmediate(callback);
-        }
-    });
-}
-
-var file = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  bytesToHumanReadable: bytesToHumanReadable,
-  bytesToKbytes: bytesToKbytes,
-  getStreamSize: getStreamSize,
-  kbytesToBytes: kbytesToBytes,
-  streamToBuffer: streamToBuffer,
-  writableDiscardStream: writableDiscardStream
-});
-
-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 createPolicyContext = (type, ctx)=>{
-    return Object.assign({
-        is: fp.eq(type),
-        get type () {
-            return type;
-        }
-    }, ctx);
-};
-
-var policy = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createPolicy: createPolicy,
-  createPolicyContext: createPolicyContext
-});
-
-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)=>_.split(it, '/'));
-    return _.join(_.takeWhile(segments, (str, index)=>otherSegments.every((it)=>it[index] === 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 trim = fp.trimChars(joint);
-    const trimEnd = fp.trimCharsEnd(joint);
-    const trimStart = fp.trimCharsStart(joint);
-    return args.reduce((url, path, index)=>{
-        if (args.length === 1) return path;
-        if (index === 0) return trimEnd(path);
-        if (index === args.length - 1) return url + joint + trimStart(path);
-        return url + joint + trim(path);
-    }, '');
-};
-const toKebabCase = (value)=>_.kebabCase(value);
-
-var strings = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getCommonPath: getCommonPath,
-  isCamelCase: isCamelCase,
-  isEqual: isEqual,
-  isKebabCase: isKebabCase,
-  joinBy: joinBy,
-  nameToCollectionName: nameToCollectionName,
-  nameToSlug: nameToSlug,
-  startsWithANumber: startsWithANumber,
-  toKebabCase: toKebabCase,
-  toRegressedEnumValue: toRegressedEnumValue
-});
-
-const castIncludes = (arr, val, cast)=>arr.map((val)=>cast(val)).includes(cast(val));
-const includesString = (arr, val)=>castIncludes(arr, val, String);
-
-var arrays = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  includesString: includesString
-});
-
-const keysDeep = (obj, path = [])=>!_.isObject(obj) ? [
-        path.join('.')
-    ] : _.reduce(obj, (acc, next, key)=>_.concat(acc, keysDeep(next, [
-            ...path,
-            key
-        ])), []);
-
-var objects = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  keysDeep: keysDeep
-});
-
-// Using timestamp (milliseconds) to be sure it is unique
-// + converting timestamp to base 36 for better readibility
-const timestampCode = (date)=>{
-    const referDate = date ?? new Date();
-    return referDate.getTime().toString(36);
-};
-
-var dates = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  timestampCode: timestampCode
-});
-
-// Code copied from the yup library (https://github.com/jquense/yup)
-// https://github.com/jquense/yup/blob/2778b88bdacd5260d593c6468793da2e77daf21f/src/util/printValue.ts
-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) {
-    // eslint-disable-next-line eqeqeq
-    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(value, quoteStrings) {
-    const result = printSimpleValue(value, quoteStrings);
-    if (result !== null) return result;
-    return JSON.stringify(value, function replacer(key, value) {
-        const result = printSimpleValue(this[key], quoteStrings);
-        if (result !== null) return result;
-        return value;
-    }, 2);
-}
-
-const strapiID = ()=>new StrapiIDSchema();
-const isNotNilTest = (value)=>!_.isNil(value);
-const isNotNullTest = (value)=>!_.isNull(value);
-yup__namespace.addMethod(yup__namespace.mixed, 'notNil', function isNotNill(msg = '${path} must be defined.') {
-    return this.test('defined', msg, isNotNilTest);
-});
-yup__namespace.addMethod(yup__namespace.mixed, 'notNull', function isNotNull(msg = '${path} cannot be null.') {
-    return this.test('defined', msg, isNotNullTest);
-});
-yup__namespace.addMethod(yup__namespace.mixed, 'isFunction', function isFunction(message = '${path} is not a function') {
-    return this.test('is a function', message, (value)=>_.isUndefined(value) || _.isFunction(value));
-});
-yup__namespace.addMethod(yup__namespace.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);
-});
-yup__namespace.addMethod(yup__namespace.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);
-});
-yup__namespace.addMethod(yup__namespace.object, 'onlyContainsFunctions', function onlyContainsFunctions(message = '${path} contains values that are not functions') {
-    return this.test('only contains functions', message, (value)=>_.isUndefined(value) || value && Object.values(value).every(_.isFunction));
-});
-yup__namespace.addMethod(yup__namespace.array, 'uniqueProperty', function uniqueProperty(propertyName, message) {
-    return this.test('unique', message, function unique(list) {
-        const errors = [];
-        list?.forEach((element, index)=>{
-            const sameElements = list.filter((e)=>fp.get(propertyName, e) === fp.get(propertyName, element));
-            if (sameElements.length > 1) {
-                errors.push(this.createError({
-                    path: `${this.path}[${index}].${propertyName}`,
-                    message
-                }));
-            }
-        });
-        if (errors.length) {
-            throw new yup__namespace.ValidationError(errors);
-        }
-        return true;
-    });
-});
-class StrapiIDSchema extends yup__namespace.MixedSchema {
-    _typeCheck(value) {
-        return typeof value === 'string' || fp.isNumber(value) && fp.isInteger(value) && value >= 0;
-    }
-    constructor(){
-        super({
-            type: 'strapiID'
-        });
-    }
-}
-// Temporary fix of this issue : https://github.com/jquense/yup/issues/616
-yup__namespace.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)}\`).` : '.'}`;
-            /* Remove comment that is not supposed to be seen by the enduser
-      if (value === null) {
-        msg += `\n If "null" is intended as an empty value be sure to mark the schema as \`.nullable()\``;
-      }
-      */ return msg;
-        }
-    }
-});
-
-var yup = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  StrapiIDSchema: StrapiIDSchema,
-  strapiID: strapiID
-}, [yup__namespace]);
-
-const validateZod = (schema)=>(data)=>{
-        try {
-            return schema.parse(data);
-        } catch (error) {
-            if (error instanceof zod.z.ZodError) {
-                const { message, errors } = formatZodErrors(error);
-                throw new ValidationError(message, {
-                    errors
-                });
-            }
-            throw error;
-        }
-    };
-const formatZodErrors = (zodError)=>({
-        errors: zodError.errors.map((error)=>{
-            return {
-                path: error.path,
-                message: error.message,
-                name: 'ValidationError'
-            };
-        }),
-        message: 'Validation error'
-    });
-
-exports.arrays = arrays;
-exports.async = async;
-exports.contentTypes = contentTypes;
-exports.dates = dates;
-exports.env = env;
-exports.errors = errors;
-exports.file = file;
-exports.hooks = hooks;
+exports.parseType = parseType;
+exports.env = envHelper;
+exports.setCreatorFields = setCreatorFields;
+exports.providerFactory = providerFactory;
+exports.traverseEntity = traverseEntity;
 exports.importDefault = importDefault;
-exports.isOperator = isOperator;
-exports.isOperatorOfType = isOperatorOfType;
 exports.machineID = machineId;
-exports.objects = objects;
-exports.packageManager = packageManager;
+exports.validateYupSchema = validators.validateYupSchema;
+exports.validateYupSchemaSync = validators.validateYupSchemaSync;
+exports.isOperator = operators.isOperator;
+exports.isOperatorOfType = operators.isOperatorOfType;
+exports.queryParams = convertQueryParams;
+exports.sanitize = index;
+exports.validate = index$1;
 exports.pagination = pagination;
-exports.parseType = parseType;
+exports.packageManager = packageManager;
+exports.traverse = index$2;
+exports.template = template;
+exports.file = file;
+exports.async = async;
 exports.policy = policy;
-exports.providerFactory = providerFactory;
-exports.queryParams = convertQueryParams;
+exports.yup = yup;
+exports.errors = errors;
+exports.contentTypes = contentTypes;
 exports.relations = relations;
-exports.sanitize = index$2;
-exports.setCreatorFields = setCreatorFields;
+exports.hooks = hooks;
+exports.validateZod = zod.validateZod;
 exports.strings = strings;
-exports.template = template;
-exports.traverse = index$3;
-exports.traverseEntity = traverseEntity$1;
-exports.validate = index;
-exports.validateYupSchema = validateYupSchema;
-exports.validateYupSchemaSync = validateYupSchemaSync;
-exports.validateZod = validateZod;
-exports.yup = yup;
+exports.arrays = arrays;
+exports.objects = objects;
+exports.dates = dates;
 //# sourceMappingURL=index.js.map