@directus/api 26.0.1 → 27.0.1

package/dist/utils/apply-query.js

@@ -1,771 +0,0 @@
-import { NUMERIC_TYPES } from '@directus/constants';
-import { InvalidQueryError } from '@directus/errors';
-import { getFilterOperatorsForType, getFunctionsForType, getOutputTypeForFunction, isIn } from '@directus/utils';
-import { clone, isPlainObject } from 'lodash-es';
-import { customAlphabet } from 'nanoid/non-secure';
-import { getHelpers } from '../database/helpers/index.js';
-import { applyCaseWhen } from '../database/run-ast/utils/apply-case-when.js';
-import { getCases } from '../permissions/modules/process-ast/lib/get-cases.js';
-import { getColumnPath } from './get-column-path.js';
-import { getColumn } from './get-column.js';
-import { getRelationInfo } from './get-relation-info.js';
-import { isValidUuid } from './is-valid-uuid.js';
-import { parseFilterKey } from './parse-filter-key.js';
-import { parseNumericString } from './parse-numeric-string.js';
-export const generateAlias = customAlphabet('abcdefghijklmnopqrstuvwxyz', 5);
-/**
- * Apply the Query to a given Knex query builder instance
- */
-export default function applyQuery(knex, collection, dbQuery, query, schema, cases, permissions, options) {
-    const aliasMap = options?.aliasMap ?? Object.create(null);
-    let hasJoins = false;
-    let hasMultiRelationalFilter = false;
-    applyLimit(knex, dbQuery, query.limit);
-    if (query.offset) {
-        applyOffset(knex, dbQuery, query.offset);
-    }
-    if (query.page && query.limit && query.limit !== -1) {
-        applyOffset(knex, dbQuery, query.limit * (query.page - 1));
-    }
-    if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
-        const sortResult = applySort(knex, schema, dbQuery, query, collection, aliasMap);
-        if (!hasJoins) {
-            hasJoins = sortResult.hasJoins;
-        }
-    }
-    // `cases` are the permissions cases that are required for the current data set. We're
-    // dynamically adding those into the filters that the user provided to enforce the permission
-    // rules. You should be able to read an item if one or more of the cases matches. The actual case
-    // is reused in the column selection case/when to dynamically return or nullify the field values
-    // you're actually allowed to read
-    const filter = joinFilterWithCases(query.filter, cases);
-    if (filter) {
-        const filterResult = applyFilter(knex, schema, dbQuery, filter, collection, aliasMap, cases, permissions);
-        if (!hasJoins) {
-            hasJoins = filterResult.hasJoins;
-        }
-        hasMultiRelationalFilter = filterResult.hasMultiRelationalFilter;
-    }
-    if (query.group) {
-        const helpers = getHelpers(knex);
-        const rawColumns = query.group.map((column) => getColumn(knex, collection, column, false, schema));
-        let columns;
-        if (options?.groupWhenCases) {
-            if (helpers.capabilities.supportsColumnPositionInGroupBy() && options.groupColumnPositions) {
-                // This can be streamlined for databases that support reusing the alias in group by expressions
-                columns = query.group.map((column, index) => options.groupColumnPositions[index] !== undefined ? knex.raw(options.groupColumnPositions[index]) : column);
-            }
-            else {
-                // Reconstruct the columns with the case/when logic
-                columns = rawColumns.map((column, index) => applyCaseWhen({
-                    columnCases: options.groupWhenCases[index].map((caseIndex) => cases[caseIndex]),
-                    column,
-                    aliasMap,
-                    cases,
-                    table: collection,
-                    permissions,
-                }, {
-                    knex,
-                    schema,
-                }));
-            }
-            if (query.sort && query.sort.length === 1 && query.sort[0] === query.group[0]) {
-                // Special case, where the sort query is injected by the group by operation
-                dbQuery.clear('order');
-                let order = 'asc';
-                if (query.sort[0].startsWith('-')) {
-                    order = 'desc';
-                }
-                // @ts-expect-error (orderBy does not accept Knex.Raw for some reason, even though it is handled correctly)
-                // https://github.com/knex/knex/issues/5711
-                dbQuery.orderBy([{ column: columns[0], order }]);
-            }
-        }
-        else {
-            columns = rawColumns;
-        }
-        dbQuery.groupBy(columns);
-    }
-    if (query.search) {
-        applySearch(knex, schema, dbQuery, query.search, collection, aliasMap, permissions);
-    }
-    if (query.aggregate) {
-        applyAggregate(schema, dbQuery, query.aggregate, collection, hasJoins);
-    }
-    return { query: dbQuery, hasJoins, hasMultiRelationalFilter };
-}
-function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, knex }) {
-    let hasMultiRelational = false;
-    let isJoinAdded = false;
-    path = clone(path);
-    followRelation(path);
-    return { hasMultiRelational, isJoinAdded };
-    function followRelation(pathParts, parentCollection = collection, parentFields) {
-        /**
-         * For A2M fields, the path can contain an optional collection scope <field>:<scope>
-         */
-        const pathRoot = pathParts[0].split(':')[0];
-        const { relation, relationType } = getRelationInfo(relations, parentCollection, pathRoot);
-        if (!relation) {
-            return;
-        }
-        const existingAlias = parentFields
-            ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias
-            : aliasMap[pathParts[0]]?.alias;
-        if (!existingAlias) {
-            const alias = generateAlias();
-            const aliasKey = parentFields ? `${parentFields}.${pathParts[0]}` : pathParts[0];
-            const aliasedParentCollection = aliasMap[parentFields ?? '']?.alias || parentCollection;
-            aliasMap[aliasKey] = { alias, collection: '' };
-            if (relationType === 'm2o') {
-                rootQuery.leftJoin({ [alias]: relation.related_collection }, `${aliasedParentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
-                aliasMap[aliasKey].collection = relation.related_collection;
-                isJoinAdded = true;
-            }
-            else if (relationType === 'a2o') {
-                const pathScope = pathParts[0].split(':')[1];
-                if (!pathScope) {
-                    throw new InvalidQueryError({
-                        reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item`,
-                    });
-                }
-                rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
-                    joinClause
-                        .onVal(`${aliasedParentCollection}.${relation.meta.one_collection_field}`, '=', pathScope)
-                        .andOn(`${aliasedParentCollection}.${relation.field}`, '=', knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), `${alias}.${schema.collections[pathScope].primary}`));
-                });
-                aliasMap[aliasKey].collection = pathScope;
-                isJoinAdded = true;
-            }
-            else if (relationType === 'o2a') {
-                rootQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
-                    joinClause
-                        .onVal(`${alias}.${relation.meta.one_collection_field}`, '=', parentCollection)
-                        .andOn(`${alias}.${relation.field}`, '=', knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), `${aliasedParentCollection}.${schema.collections[parentCollection].primary}`));
-                });
-                aliasMap[aliasKey].collection = relation.collection;
-                hasMultiRelational = true;
-                isJoinAdded = true;
-            }
-            else if (relationType === 'o2m') {
-                rootQuery.leftJoin({ [alias]: relation.collection }, `${aliasedParentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
-                aliasMap[aliasKey].collection = relation.collection;
-                hasMultiRelational = true;
-                isJoinAdded = true;
-            }
-        }
-        let parent;
-        if (relationType === 'm2o') {
-            parent = relation.related_collection;
-        }
-        else if (relationType === 'a2o') {
-            const pathScope = pathParts[0].split(':')[1];
-            if (!pathScope) {
-                throw new InvalidQueryError({
-                    reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item`,
-                });
-            }
-            parent = pathScope;
-        }
-        else {
-            parent = relation.collection;
-        }
-        if (pathParts.length > 1) {
-            followRelation(pathParts.slice(1), parent, `${parentFields ? parentFields + '.' : ''}${pathParts[0]}`);
-        }
-    }
-}
-export function applySort(knex, schema, rootQuery, query, collection, aliasMap, returnRecords = false) {
-    const rootSort = query.sort;
-    const aggregate = query?.aggregate;
-    const relations = schema.relations;
-    let hasJoins = false;
-    let hasMultiRelationalSort = false;
-    const sortRecords = rootSort.map((sortField) => {
-        const column = sortField.split('.');
-        let order = 'asc';
-        if (sortField.startsWith('-')) {
-            order = 'desc';
-        }
-        if (column[0].startsWith('-')) {
-            column[0] = column[0].substring(1);
-        }
-        // Is the column name one of the aggregate functions used in the query if there is any?
-        if (Object.keys(aggregate ?? {}).includes(column[0])) {
-            // If so, return the column name without the order prefix
-            const operation = column[0];
-            // Get the field for the aggregate function
-            const field = column[1];
-            // If the operation is countAll there is no field.
-            if (operation === 'countAll') {
-                return {
-                    order,
-                    column: 'countAll',
-                };
-            }
-            // If the operation is a root count there is no field.
-            if (operation === 'count' && (field === '*' || !field)) {
-                return {
-                    order,
-                    column: 'count',
-                };
-            }
-            // Return the column name with the operation and field name
-            return {
-                order,
-                column: returnRecords ? column[0] : `${operation}->${field}`,
-            };
-        }
-        if (column.length === 1) {
-            const pathRoot = column[0].split(':')[0];
-            const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);
-            if (!relation || ['m2o', 'a2o'].includes(relationType ?? '')) {
-                return {
-                    order,
-                    column: returnRecords ? column[0] : getColumn(knex, collection, column[0], false, schema),
-                };
-            }
-        }
-        const { hasMultiRelational, isJoinAdded } = addJoin({
-            path: column,
-            collection,
-            aliasMap,
-            rootQuery,
-            schema,
-            relations,
-            knex,
-        });
-        const { columnPath } = getColumnPath({
-            path: column,
-            collection,
-            aliasMap,
-            relations,
-            schema,
-        });
-        const [alias, field] = columnPath.split('.');
-        if (!hasJoins) {
-            hasJoins = isJoinAdded;
-        }
-        if (!hasMultiRelationalSort) {
-            hasMultiRelationalSort = hasMultiRelational;
-        }
-        return {
-            order,
-            column: returnRecords ? columnPath : getColumn(knex, alias, field, false, schema),
-        };
-    });
-    if (returnRecords)
-        return { sortRecords, hasJoins, hasMultiRelationalSort };
-    // Clears the order if any, eg: from MSSQL offset
-    rootQuery.clear('order');
-    rootQuery.orderBy(sortRecords);
-    return { hasJoins, hasMultiRelationalSort };
-}
-export function applyLimit(knex, rootQuery, limit) {
-    if (typeof limit === 'number') {
-        getHelpers(knex).schema.applyLimit(rootQuery, limit);
-    }
-}
-export function applyOffset(knex, rootQuery, offset) {
-    if (typeof offset === 'number') {
-        getHelpers(knex).schema.applyOffset(rootQuery, offset);
-    }
-}
-export function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap, cases, permissions) {
-    const helpers = getHelpers(knex);
-    const relations = schema.relations;
-    let hasJoins = false;
-    let hasMultiRelationalFilter = false;
-    addJoins(rootQuery, rootFilter, collection);
-    addWhereClauses(knex, rootQuery, rootFilter, collection);
-    return { query: rootQuery, hasJoins, hasMultiRelationalFilter };
-    function addJoins(dbQuery, filter, collection) {
-        // eslint-disable-next-line prefer-const
-        for (let [key, value] of Object.entries(filter)) {
-            if (key === '_or' || key === '_and') {
-                // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
-                // permission checks, as {} already matches full permissions.
-                if (key === '_or' && value.some((subFilter) => Object.keys(subFilter).length === 0)) {
-                    // But only do so, if the value is not equal to `cases` (since then this is not permission related at all)
-                    // or the length of value is 1, ie. only the empty filter.
-                    // If the length is more than one it means that some items (and fields) might now be available, so
-                    // the joins are required for the case/when construction.
-                    if (value !== cases || value.length === 1) {
-                        continue;
-                    }
-                    else {
-                        // Otherwise we can at least filter out all empty filters that would not add joins anyway
-                        value = value.filter((subFilter) => Object.keys(subFilter).length > 0);
-                    }
-                }
-                value.forEach((subFilter) => {
-                    addJoins(dbQuery, subFilter, collection);
-                });
-                continue;
-            }
-            const filterPath = getFilterPath(key, value);
-            if (filterPath.length > 1 ||
-                (!(key.includes('(') && key.includes(')')) && schema.collections[collection]?.fields[key]?.type === 'alias')) {
-                const { hasMultiRelational, isJoinAdded } = addJoin({
-                    path: filterPath,
-                    collection,
-                    knex,
-                    schema,
-                    relations,
-                    rootQuery,
-                    aliasMap,
-                });
-                if (!hasJoins) {
-                    hasJoins = isJoinAdded;
-                }
-                if (!hasMultiRelationalFilter) {
-                    hasMultiRelationalFilter = hasMultiRelational;
-                }
-            }
-        }
-    }
-    function addWhereClauses(knex, dbQuery, filter, collection, logical = 'and') {
-        for (const [key, value] of Object.entries(filter)) {
-            if (key === '_or' || key === '_and') {
-                // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
-                // permission checks, as {} already matches full permissions.
-                if (key === '_or' && value.some((subFilter) => Object.keys(subFilter).length === 0)) {
-                    continue;
-                }
-                /** @NOTE this callback function isn't called until Knex runs the query */
-                dbQuery[logical].where((subQuery) => {
-                    value.forEach((subFilter) => {
-                        addWhereClauses(knex, subQuery, subFilter, collection, key === '_and' ? 'and' : 'or');
-                    });
-                });
-                continue;
-            }
-            const filterPath = getFilterPath(key, value);
-            /**
-             * For A2M fields, the path can contain an optional collection scope <field>:<scope>
-             */
-            const pathRoot = filterPath[0].split(':')[0];
-            const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);
-            const operation = getOperation(key, value);
-            if (!operation)
-                continue;
-            const { operator: filterOperator, value: filterValue } = operation;
-            if (filterPath.length > 1 ||
-                (!(key.includes('(') && key.includes(')')) && schema.collections[collection]?.fields[key]?.type === 'alias')) {
-                if (!relation)
-                    continue;
-                if (relationType === 'o2m' || relationType === 'o2a') {
-                    let pkField = `${collection}.${schema.collections[relation.related_collection].primary}`;
-                    if (relationType === 'o2a') {
-                        pkField = knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), [pkField]);
-                    }
-                    const childKey = Object.keys(value)?.[0];
-                    if (childKey === '_none' || childKey === '_some') {
-                        const subQueryBuilder = (filter, cases) => (subQueryKnex) => {
-                            const field = relation.field;
-                            const collection = relation.collection;
-                            const column = `${collection}.${field}`;
-                            subQueryKnex
-                                .select({ [field]: column })
-                                .from(collection)
-                                .whereNotNull(column);
-                            applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema, cases, permissions);
-                        };
-                        const { cases: subCases } = getCases(relation.collection, permissions, []);
-                        if (childKey === '_none') {
-                            dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0], subCases));
-                            continue;
-                        }
-                        else if (childKey === '_some') {
-                            dbQuery[logical].whereIn(pkField, subQueryBuilder(Object.values(value)[0], subCases));
-                            continue;
-                        }
-                    }
-                }
-                if (filterPath.includes('_none') || filterPath.includes('_some')) {
-                    throw new InvalidQueryError({
-                        reason: `"${filterPath.includes('_none') ? '_none' : '_some'}" can only be used with top level relational alias field`,
-                    });
-                }
-                const { columnPath, targetCollection, addNestedPkField } = getColumnPath({
-                    path: filterPath,
-                    collection,
-                    relations,
-                    aliasMap,
-                    schema,
-                });
-                if (addNestedPkField) {
-                    filterPath.push(addNestedPkField);
-                }
-                if (!columnPath)
-                    continue;
-                const { type, special } = getFilterType(schema.collections[targetCollection].fields, filterPath.at(-1), targetCollection);
-                validateFilterOperator(type, filterOperator, special);
-                applyFilterToQuery(columnPath, filterOperator, filterValue, logical, targetCollection);
-            }
-            else {
-                const { type, special } = getFilterType(schema.collections[collection].fields, filterPath[0], collection);
-                validateFilterOperator(type, filterOperator, special);
-                const aliasedCollection = aliasMap['']?.alias || collection;
-                applyFilterToQuery(`${aliasedCollection}.${filterPath[0]}`, filterOperator, filterValue, logical, collection);
-            }
-        }
-        function getFilterType(fields, key, collection = 'unknown') {
-            const { fieldName, functionName } = parseFilterKey(key);
-            const field = fields[fieldName];
-            if (!field) {
-                throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
-            }
-            const { type } = field;
-            if (functionName) {
-                const availableFunctions = getFunctionsForType(type);
-                if (!availableFunctions.includes(functionName)) {
-                    throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
-                }
-                const functionType = getOutputTypeForFunction(functionName);
-                return { type: functionType };
-            }
-            return { type, special: field.special };
-        }
-        function validateFilterOperator(type, filterOperator, special) {
-            if (filterOperator.startsWith('_')) {
-                filterOperator = filterOperator.slice(1);
-            }
-            if (!getFilterOperatorsForType(type).includes(filterOperator)) {
-                throw new InvalidQueryError({
-                    reason: `"${type}" field type does not contain the "_${filterOperator}" filter operator`,
-                });
-            }
-            if (special?.includes('conceal') &&
-                !getFilterOperatorsForType('hash').includes(filterOperator)) {
-                throw new InvalidQueryError({
-                    reason: `Field with "conceal" special does not allow the "_${filterOperator}" filter operator`,
-                });
-            }
-        }
-        function applyFilterToQuery(key, operator, compareValue, logical = 'and', originalCollectionName) {
-            const [table, column] = key.split('.');
-            // Is processed through Knex.Raw, so should be safe to string-inject into these where queries
-            const selectionRaw = getColumn(knex, table, column, false, schema, { originalCollectionName });
-            // Knex supports "raw" in the columnName parameter, but isn't typed as such. Too bad..
-            // See https://github.com/knex/knex/issues/4518 @TODO remove as any once knex is updated
-            // These operators don't rely on a value, and can thus be used without one (eg `?filter[field][_null]`)
-            if ((operator === '_null' && compareValue !== false) ||
-                (operator === '_nnull' && compareValue === false) ||
-                (operator === '_eq' && compareValue === null)) {
-                dbQuery[logical].whereNull(selectionRaw);
-                return;
-            }
-            if ((operator === '_nnull' && compareValue !== false) ||
-                (operator === '_null' && compareValue === false) ||
-                (operator === '_neq' && compareValue === null)) {
-                dbQuery[logical].whereNotNull(selectionRaw);
-                return;
-            }
-            if ((operator === '_empty' && compareValue !== false) || (operator === '_nempty' && compareValue === false)) {
-                dbQuery[logical].andWhere((query) => {
-                    query.whereNull(key).orWhere(key, '=', '');
-                });
-            }
-            if ((operator === '_nempty' && compareValue !== false) || (operator === '_empty' && compareValue === false)) {
-                dbQuery[logical].andWhere((query) => {
-                    query.whereNotNull(key).andWhere(key, '!=', '');
-                });
-            }
-            // The following fields however, require a value to be run. If no value is passed, we
-            // ignore them. This allows easier use in GraphQL, where you wouldn't be able to
-            // conditionally build out your filter structure (#4471)
-            if (compareValue === undefined)
-                return;
-            if (Array.isArray(compareValue)) {
-                // Tip: when using a `[Type]` type in GraphQL, but don't provide the variable, it'll be
-                // reported as [undefined].
-                // We need to remove any undefined values, as they are useless
-                compareValue = compareValue.filter((val) => val !== undefined);
-            }
-            // Cast filter value (compareValue) based on function used
-            if (column.includes('(') && column.includes(')')) {
-                const functionName = column.split('(')[0];
-                const type = getOutputTypeForFunction(functionName);
-                if (['integer', 'float', 'decimal'].includes(type)) {
-                    compareValue = Array.isArray(compareValue) ? compareValue.map(Number) : Number(compareValue);
-                }
-            }
-            // Cast filter value (compareValue) based on type of field being filtered against
-            const [collection, field] = key.split('.');
-            const mappedCollection = (originalCollectionName || collection);
-            if (mappedCollection in schema.collections && field in schema.collections[mappedCollection].fields) {
-                const type = schema.collections[mappedCollection].fields[field].type;
-                if (['date', 'dateTime', 'time', 'timestamp'].includes(type)) {
-                    if (Array.isArray(compareValue)) {
-                        compareValue = compareValue.map((val) => helpers.date.parse(val));
-                    }
-                    else {
-                        compareValue = helpers.date.parse(compareValue);
-                    }
-                }
-                if (['integer', 'float', 'decimal'].includes(type)) {
-                    if (Array.isArray(compareValue)) {
-                        compareValue = compareValue.map((val) => Number(val));
-                    }
-                    else {
-                        compareValue = Number(compareValue);
-                    }
-                }
-            }
-            if (operator === '_eq') {
-                dbQuery[logical].where(selectionRaw, '=', compareValue);
-            }
-            if (operator === '_neq') {
-                dbQuery[logical].whereNot(selectionRaw, compareValue);
-            }
-            if (operator === '_ieq') {
-                dbQuery[logical].whereRaw(`LOWER(??) = ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
-            }
-            if (operator === '_nieq') {
-                dbQuery[logical].whereRaw(`LOWER(??) <> ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
-            }
-            if (operator === '_contains') {
-                dbQuery[logical].where(selectionRaw, 'like', `%${compareValue}%`);
-            }
-            if (operator === '_ncontains') {
-                dbQuery[logical].whereNot(selectionRaw, 'like', `%${compareValue}%`);
-            }
-            if (operator === '_icontains') {
-                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
-            }
-            if (operator === '_nicontains') {
-                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
-            }
-            if (operator === '_starts_with') {
-                dbQuery[logical].where(key, 'like', `${compareValue}%`);
-            }
-            if (operator === '_nstarts_with') {
-                dbQuery[logical].whereNot(key, 'like', `${compareValue}%`);
-            }
-            if (operator === '_istarts_with') {
-                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
-            }
-            if (operator === '_nistarts_with') {
-                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
-            }
-            if (operator === '_ends_with') {
-                dbQuery[logical].where(key, 'like', `%${compareValue}`);
-            }
-            if (operator === '_nends_with') {
-                dbQuery[logical].whereNot(key, 'like', `%${compareValue}`);
-            }
-            if (operator === '_iends_with') {
-                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
-            }
-            if (operator === '_niends_with') {
-                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
-            }
-            if (operator === '_gt') {
-                dbQuery[logical].where(selectionRaw, '>', compareValue);
-            }
-            if (operator === '_gte') {
-                dbQuery[logical].where(selectionRaw, '>=', compareValue);
-            }
-            if (operator === '_lt') {
-                dbQuery[logical].where(selectionRaw, '<', compareValue);
-            }
-            if (operator === '_lte') {
-                dbQuery[logical].where(selectionRaw, '<=', compareValue);
-            }
-            if (operator === '_in') {
-                let value = compareValue;
-                if (typeof value === 'string')
-                    value = value.split(',');
-                dbQuery[logical].whereIn(selectionRaw, value);
-            }
-            if (operator === '_nin') {
-                let value = compareValue;
-                if (typeof value === 'string')
-                    value = value.split(',');
-                dbQuery[logical].whereNotIn(selectionRaw, value);
-            }
-            if (operator === '_between') {
-                let value = compareValue;
-                if (typeof value === 'string')
-                    value = value.split(',');
-                if (value.length !== 2)
-                    return;
-                dbQuery[logical].whereBetween(selectionRaw, value);
-            }
-            if (operator === '_nbetween') {
-                let value = compareValue;
-                if (typeof value === 'string')
-                    value = value.split(',');
-                if (value.length !== 2)
-                    return;
-                dbQuery[logical].whereNotBetween(selectionRaw, value);
-            }
-            if (operator == '_intersects') {
-                dbQuery[logical].whereRaw(helpers.st.intersects(key, compareValue));
-            }
-            if (operator == '_nintersects') {
-                dbQuery[logical].whereRaw(helpers.st.nintersects(key, compareValue));
-            }
-            if (operator == '_intersects_bbox') {
-                dbQuery[logical].whereRaw(helpers.st.intersects_bbox(key, compareValue));
-            }
-            if (operator == '_nintersects_bbox') {
-                dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
-            }
-        }
-    }
-}
-export function applySearch(knex, schema, dbQuery, searchQuery, collection, aliasMap, permissions) {
-    const { number: numberHelper } = getHelpers(knex);
-    const allowedFields = new Set(permissions.filter((p) => p.collection === collection).flatMap((p) => p.fields ?? []));
-    let fields = Object.entries(schema.collections[collection].fields);
-    const { cases, caseMap } = getCases(collection, permissions, []);
-    // Add field restrictions if non-admin and "everything" is not allowed
-    if (cases.length !== 0 && !allowedFields.has('*')) {
-        fields = fields.filter((field) => allowedFields.has(field[0]));
-    }
-    dbQuery.andWhere(function (queryBuilder) {
-        let needsFallbackCondition = true;
-        fields.forEach(([name, field]) => {
-            // only account for when cases when full access is not given
-            const whenCases = allowedFields.has('*') ? [] : (caseMap[name] ?? []).map((caseIndex) => cases[caseIndex]);
-            const fieldType = getFieldType(field);
-            if (fieldType !== null) {
-                needsFallbackCondition = false;
-            }
-            else {
-                return;
-            }
-            if (cases.length !== 0 && whenCases?.length !== 0) {
-                queryBuilder.orWhere((subQuery) => {
-                    addSearchCondition(subQuery, name, fieldType, 'and');
-                    applyFilter(knex, schema, subQuery, { _or: whenCases }, collection, aliasMap, cases, permissions);
-                });
-            }
-            else {
-                addSearchCondition(queryBuilder, name, fieldType, 'or');
-            }
-        });
-        if (needsFallbackCondition) {
-            queryBuilder.orWhereRaw('1 = 0');
-        }
-    });
-    function addSearchCondition(queryBuilder, name, fieldType, logical) {
-        if (fieldType === null) {
-            return;
-        }
-        if (fieldType === 'string') {
-            queryBuilder[logical].whereRaw(`LOWER(??) LIKE ?`, [`${collection}.${name}`, `%${searchQuery.toLowerCase()}%`]);
-        }
-        else if (fieldType === 'numeric') {
-            numberHelper.addSearchCondition(queryBuilder, collection, name, parseNumericString(searchQuery), logical);
-        }
-        else if (fieldType === 'uuid') {
-            queryBuilder[logical].where({ [`${collection}.${name}`]: searchQuery });
-        }
-    }
-    function getFieldType(field) {
-        if (['text', 'string'].includes(field.type)) {
-            return 'string';
-        }
-        if (isNumericField(field)) {
-            const number = parseNumericString(searchQuery);
-            if (number === null) {
-                return null;
-            }
-            if (numberHelper.isNumberValid(number, field)) {
-                return 'numeric';
-            }
-        }
-        if (field.type === 'uuid' && isValidUuid(searchQuery)) {
-            return 'uuid';
-        }
-        return null;
-    }
-}
-export function applyAggregate(schema, dbQuery, aggregate, collection, hasJoins) {
-    for (const [operation, fields] of Object.entries(aggregate)) {
-        if (!fields)
-            continue;
-        for (const field of fields) {
-            if (operation === 'avg') {
-                dbQuery.avg(`${collection}.${field}`, { as: `avg->${field}` });
-            }
-            if (operation === 'avgDistinct') {
-                dbQuery.avgDistinct(`${collection}.${field}`, { as: `avgDistinct->${field}` });
-            }
-            if (operation === 'countAll') {
-                dbQuery.count('*', { as: 'countAll' });
-            }
-            if (operation === 'count') {
-                if (field === '*') {
-                    dbQuery.count('*', { as: 'count' });
-                }
-                else {
-                    dbQuery.count(`${collection}.${field}`, { as: `count->${field}` });
-                }
-            }
-            if (operation === 'countDistinct') {
-                if (!hasJoins && schema.collections[collection]?.primary === field) {
-                    // Optimize to count as primary keys are unique
-                    dbQuery.count(`${collection}.${field}`, { as: `countDistinct->${field}` });
-                }
-                else {
-                    dbQuery.countDistinct(`${collection}.${field}`, { as: `countDistinct->${field}` });
-                }
-            }
-            if (operation === 'sum') {
-                dbQuery.sum(`${collection}.${field}`, { as: `sum->${field}` });
-            }
-            if (operation === 'sumDistinct') {
-                dbQuery.sumDistinct(`${collection}.${field}`, { as: `sumDistinct->${field}` });
-            }
-            if (operation === 'min') {
-                dbQuery.min(`${collection}.${field}`, { as: `min->${field}` });
-            }
-            if (operation === 'max') {
-                dbQuery.max(`${collection}.${field}`, { as: `max->${field}` });
-            }
-        }
-    }
-}
-export function joinFilterWithCases(filter, cases) {
-    if (cases.length > 0 && !filter) {
-        return { _or: cases };
-    }
-    else if (filter && cases.length === 0) {
-        return filter ?? null;
-    }
-    else if (filter && cases.length > 0) {
-        return { _and: [filter, { _or: cases }] };
-    }
-    return null;
-}
-function getFilterPath(key, value) {
-    const path = [key];
-    const childKey = Object.keys(value)[0];
-    if (!childKey || (childKey.startsWith('_') === true && !['_none', '_some'].includes(childKey))) {
-        return path;
-    }
-    if (isPlainObject(value)) {
-        path.push(...getFilterPath(childKey, Object.values(value)[0]));
-    }
-    return path;
-}
-function getOperation(key, value) {
-    if (key.startsWith('_') && !['_and', '_or', '_none', '_some'].includes(key)) {
-        return { operator: key, value };
-    }
-    else if (!isPlainObject(value)) {
-        return { operator: '_eq', value };
-    }
-    const childKey = Object.keys(value)[0];
-    if (childKey) {
-        return getOperation(childKey, Object.values(value)[0]);
-    }
-    return null;
-}
-function isNumericField(field) {
-    return isIn(field.type, NUMERIC_TYPES);
-}