directus 9.9.1 → 9.11.1

package/dist/services/items.js

@@ -15,8 +15,9 @@ const translate_1 = require("../exceptions/database/translate");
 const types_1 = require("../types");
 const get_ast_from_query_1 = __importDefault(require("../utils/get-ast-from-query"));
 const authorization_1 = require("./authorization");
-const payload_1 = require("./payload");
 const index_1 = require("./index");
+const payload_1 = require("./payload");
+const validate_keys_1 = require("../utils/validate-keys");
 class ItemsService {
     constructor(collection, options) {
         this.collection = collection;
@@ -90,8 +91,13 @@ class ItemsService {
             // In case of manual string / UUID primary keys, the PK already exists in the object we're saving.
             let primaryKey = payloadWithTypeCasting[primaryKeyField];
             try {
-                const result = await trx.insert(payloadWithoutAliases).into(this.collection).returning(primaryKeyField);
-                primaryKey = primaryKey !== null && primaryKey !== void 0 ? primaryKey : result[0];
+                const result = await trx
+                    .insert(payloadWithoutAliases)
+                    .into(this.collection)
+                    .returning(primaryKeyField)
+                    .then((result) => result[0]);
+                const returnedKey = typeof result === 'object' ? result[primaryKeyField] : result;
+                primaryKey = primaryKey !== null && primaryKey !== void 0 ? primaryKey : returnedKey;
             }
             catch (err) {
                 throw await (0, translate_1.translateDatabaseError)(err);
@@ -239,6 +245,7 @@ class ItemsService {
      */
     async readOne(key, query = {}, opts) {
         const primaryKeyField = this.schema.collections[this.collection].primary;
+        (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, key);
         const filterWithKey = (0, lodash_1.assign)({}, query.filter, { [primaryKeyField]: { _eq: key } });
         const queryWithKey = (0, lodash_1.assign)({}, query, { filter: filterWithKey });
         const results = await this.readByQuery(queryWithKey, opts);
@@ -253,8 +260,13 @@ class ItemsService {
     async readMany(keys, query = {}, opts) {
         var _a;
         const primaryKeyField = this.schema.collections[this.collection].primary;
+        (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, keys);
         const filterWithKey = { _and: [{ [primaryKeyField]: { _in: keys } }, (_a = query.filter) !== null && _a !== void 0 ? _a : {}] };
         const queryWithKey = (0, lodash_1.assign)({}, query, { filter: filterWithKey });
+        // Set query limit as the number of keys
+        if (Array.isArray(keys) && keys.length > 0 && !queryWithKey.limit) {
+            queryWithKey.limit = keys.length;
+        }
         const results = await this.readByQuery(queryWithKey, opts);
         return results;
     }
@@ -263,12 +275,16 @@ class ItemsService {
      */
     async updateByQuery(query, data, opts) {
         const keys = await this.getKeysByQuery(query);
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, keys);
         return keys.length ? await this.updateMany(keys, data, opts) : [];
     }
     /**
      * Update a single item by primary key
      */
     async updateOne(key, data, opts) {
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, key);
         await this.updateMany([key], data, opts);
         return key;
     }
@@ -277,6 +293,7 @@ class ItemsService {
      */
     async updateMany(keys, data, opts) {
         const primaryKeyField = this.schema.collections[this.collection].primary;
+        (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, keys);
         const fields = Object.keys(this.schema.collections[this.collection].fields);
         const aliases = Object.values(this.schema.collections[this.collection].fields)
             .filter((field) => field.alias === true)
@@ -301,6 +318,8 @@ class ItemsService {
                 accountability: this.accountability,
             })
             : payload;
+        // Sort keys to ensure that the order is maintained
+        keys.sort();
         if (this.accountability) {
             await authorizationService.checkAccess('update', this.collection, keys);
         }
@@ -404,6 +423,9 @@ class ItemsService {
     async upsertOne(payload, opts) {
         const primaryKeyField = this.schema.collections[this.collection].primary;
         const primaryKey = payload[primaryKeyField];
+        if (primaryKey) {
+            (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, primaryKey);
+        }
         const exists = primaryKey &&
             !!(await this.knex
                 .select(primaryKeyField)
@@ -444,12 +466,16 @@ class ItemsService {
      */
     async deleteByQuery(query, opts) {
         const keys = await this.getKeysByQuery(query);
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, keys);
         return keys.length ? await this.deleteMany(keys, opts) : [];
     }
     /**
      * Delete a single item by primary key
      */
     async deleteOne(key, opts) {
+        const primaryKeyField = this.schema.collections[this.collection].primary;
+        (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, key);
         await this.deleteMany([key], opts);
         return key;
     }
@@ -458,10 +484,12 @@ class ItemsService {
      */
     async deleteMany(keys, opts) {
         const primaryKeyField = this.schema.collections[this.collection].primary;
+        (0, validate_keys_1.validateKeys)(this.schema, this.collection, primaryKeyField, keys);
         if (this.accountability && this.accountability.admin !== true) {
             const authorizationService = new authorization_1.AuthorizationService({
                 accountability: this.accountability,
                 schema: this.schema,
+                knex: this.knex,
             });
             await authorizationService.checkAccess('delete', this.collection, keys);
         }

package/dist/services/payload.d.ts

@@ -1,7 +1,7 @@
-import { Knex } from 'knex';
-import { AbstractServiceOptions, Item, PrimaryKey } from '../types';
 import { Accountability, SchemaOverview } from '@directus/shared/types';
+import { Knex } from 'knex';
 import { Helpers } from '../database/helpers';
+import { AbstractServiceOptions, Item, PrimaryKey } from '../types';
 declare type Action = 'create' | 'read' | 'update';
 declare type Transformers = {
     [type: string]: (context: {

package/dist/services/payload.js

@@ -4,18 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PayloadService = void 0;
+const utils_1 = require("@directus/shared/utils");
 const date_fns_1 = require("date-fns");
+const flat_1 = require("flat");
 const joi_1 = __importDefault(require("joi"));
 const lodash_1 = require("lodash");
 const uuid_1 = require("uuid");
+const wellknown_1 = require("wellknown");
 const database_1 = __importDefault(require("../database"));
-const exceptions_1 = require("../exceptions");
-const utils_1 = require("@directus/shared/utils");
-const items_1 = require("./items");
-const flat_1 = require("flat");
 const helpers_1 = require("../database/helpers");
-const wellknown_1 = require("wellknown");
+const exceptions_1 = require("../exceptions");
 const generate_hash_1 = require("../utils/generate-hash");
+const parse_json_1 = require("../utils/parse-json");
+const items_1 = require("./items");
 /**
  * Process a given payload for a collection to ensure the special fields (hash, uuid, date etc) are
  * handled correctly.
@@ -55,7 +56,7 @@ class PayloadService {
                 if (action === 'read') {
                     if (typeof value === 'string') {
                         try {
-                            return JSON.parse(value);
+                            return (0, parse_json_1.parseJSON)(value);
                         }
                         catch {
                             return value;
@@ -196,7 +197,7 @@ class PayloadService {
     processGeometries(payloads, action) {
         const process = action == 'read'
             ? (value) => (typeof value === 'string' ? (0, wellknown_1.parse)(value) : value)
-            : (value) => this.helpers.st.fromGeoJSON(typeof value == 'string' ? JSON.parse(value) : value);
+            : (value) => this.helpers.st.fromGeoJSON(typeof value == 'string' ? (0, parse_json_1.parseJSON)(value) : value);
         const fieldsInCollection = Object.entries(this.schema.collections[this.collection].fields);
         const geometryColumns = fieldsInCollection.filter(([_, field]) => field.type.startsWith('geometry'));
         for (const [name] of geometryColumns) {
@@ -318,7 +319,7 @@ class PayloadService {
             }
             const allowedCollections = relation.meta.one_allowed_collections;
             if (allowedCollections.includes(relatedCollection) === false) {
-                throw new exceptions_1.InvalidPayloadException(`"${relation.collection}.${relation.field}" can't be linked to collection "${relatedCollection}`);
+                throw new exceptions_1.InvalidPayloadException(`"${relation.collection}.${relation.field}" can't be linked to collection "${relatedCollection}"`);
             }
             const itemsService = new items_1.ItemsService(relatedCollection, {
                 accountability: this.accountability,

package/dist/services/users.d.ts

@@ -18,6 +18,10 @@ export declare class UsersService extends ItemsService {
      */
     private checkPasswordPolicy;
     private checkRemainingAdminExistence;
+    /**
+     * Make sure there's at least one active admin user when updating user status
+     */
+    private checkRemainingActiveAdmin;
     /**
      * Create a new user
      */

package/dist/services/users.js

@@ -101,6 +101,23 @@ class UsersService extends items_1.ItemsService {
             throw new exceptions_2.UnprocessableEntityException(`You can't remove the last admin user from the role.`);
         }
     }
+    /**
+     * Make sure there's at least one active admin user when updating user status
+     */
+    async checkRemainingActiveAdmin(excludeKeys) {
+        const otherAdminUsers = await this.knex
+            .count('*', { as: 'count' })
+            .from('directus_users')
+            .whereNotIn('directus_users.id', excludeKeys)
+            .andWhere({ 'directus_roles.admin_access': true })
+            .andWhere({ 'directus_users.status': 'active' })
+            .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+            .first();
+        const otherAdminUsersCount = +((otherAdminUsers === null || otherAdminUsers === void 0 ? void 0 : otherAdminUsers.count) || 0);
+        if (otherAdminUsersCount === 0) {
+            throw new exceptions_2.UnprocessableEntityException(`You can't change the active status of the last admin user.`);
+        }
+    }
     /**
      * Create a new user
      */
@@ -149,6 +166,9 @@ class UsersService extends items_1.ItemsService {
                 await this.checkRemainingAdminExistence(keys);
             }
         }
+        if (data.status !== undefined && data.status !== 'active') {
+            await this.checkRemainingActiveAdmin(keys);
+        }
         if (data.email) {
             if (keys.length > 1) {
                 throw new record_not_unique_1.RecordNotUniqueException('email', {

package/dist/utils/apply-query.d.ts

@@ -1,9 +1,10 @@
-import { Knex } from 'knex';
 import { Aggregate, Filter, Query, SchemaOverview } from '@directus/shared/types';
+import { Knex } from 'knex';
 /**
  * Apply the Query to a given Knex query builder instance
  */
 export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, subQuery?: boolean): Knex.QueryBuilder;
+export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootSort: string[], collection: string, subQuery?: boolean): void;
 export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, subQuery?: boolean): Knex.QueryBuilder<any, any>;
 export declare function applySearch(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): Promise<void>;
 export declare function applyAggregate(dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string): void;

package/dist/utils/apply-query.js

@@ -3,14 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyAggregate = exports.applySearch = exports.applyFilter = void 0;
+exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.applySort = void 0;
 const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
-const exceptions_1 = require("../exceptions");
-const get_column_1 = require("./get-column");
-const get_relation_type_1 = require("./get-relation-type");
 const helpers_1 = require("../database/helpers");
+const invalid_query_1 = require("../exceptions/invalid-query");
+const get_column_1 = require("./get-column");
+const get_column_path_1 = require("./get-column-path");
+const get_relation_info_1 = require("./get-relation-info");
 const utils_1 = require("@directus/shared/utils");
 const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
 /**
@@ -18,18 +19,7 @@ const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz',
  */
 function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false) {
     if (query.sort) {
-        dbQuery.orderBy(query.sort.map((sortField) => {
-            let column = sortField;
-            let order = 'asc';
-            if (sortField.startsWith('-')) {
-                column = column.substring(1);
-                order = 'desc';
-            }
-            return {
-                order,
-                column: (0, get_column_1.getColumn)(knex, collection, column, false, schema),
-            };
-        }));
+        applySort(knex, schema, dbQuery, query.sort, collection, subQuery);
     }
     if (typeof query.limit === 'number' && query.limit !== -1) {
         dbQuery.limit(query.limit);
@@ -55,44 +45,109 @@ function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false)
     return dbQuery;
 }
 exports.default = applyQuery;
-function getRelationInfo(relations, collection, field) {
-    var _a, _b;
-    const implicitRelation = (_a = field.match(/^\$FOLLOW\((.*?),(.*?)(?:,(.*?))?\)$/)) === null || _a === void 0 ? void 0 : _a.slice(1);
-    if (implicitRelation) {
-        if (implicitRelation[2] === undefined) {
-            const [m2oCollection, m2oField] = implicitRelation;
-            const relation = {
-                collection: m2oCollection,
-                field: m2oField,
-                related_collection: collection,
-                schema: null,
-                meta: null,
-            };
-            return { relation, relationType: 'o2m' };
+function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, relations, knex }) {
+    path = (0, lodash_1.clone)(path);
+    followRelation(path);
+    function followRelation(pathParts, parentCollection = collection, parentAlias) {
+        /**
+         * For A2M fields, the path can contain an optional collection scope <field>:<scope>
+         */
+        const pathRoot = pathParts[0].split(':')[0];
+        const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, parentCollection, pathRoot);
+        if (!relation) {
+            return;
         }
-        else {
-            const [a2oCollection, a2oItemField, a2oCollectionField] = implicitRelation;
-            const relation = {
-                collection: a2oCollection,
-                field: a2oItemField,
-                related_collection: collection,
-                schema: null,
-                meta: {
-                    one_collection_field: a2oCollectionField,
-                    one_field: field,
-                },
-            };
-            return { relation, relationType: 'o2a' };
+        const alias = generateAlias();
+        (0, lodash_1.set)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts, alias);
+        if (relationType === 'm2o') {
+            rootQuery.leftJoin({ [alias]: relation.related_collection }, `${parentAlias || parentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
+        }
+        if (relationType === 'a2o') {
+            const pathScope = pathParts[0].split(':')[1];
+            if (!pathScope) {
+                throw new invalid_query_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+            }
+            rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
+                joinClause
+                    .onVal(relation.meta.one_collection_field, '=', pathScope)
+                    .andOn(`${parentAlias || parentCollection}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${alias}.${schema.collections[pathScope].primary}`));
+            });
+        }
+        if (relationType === 'o2a') {
+            rootQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
+                joinClause
+                    .onVal(relation.meta.one_collection_field, '=', parentCollection)
+                    .andOn(`${alias}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${parentAlias || parentCollection}.${schema.collections[parentCollection].primary}`));
+            });
+        }
+        // Still join o2m relations when in subquery OR when the o2m relation is not at the root level
+        if (relationType === 'o2m' && (subQuery === true || parentAlias !== undefined)) {
+            rootQuery.leftJoin({ [alias]: relation.collection }, `${parentAlias || parentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
+        }
+        if (relationType === 'm2o' || subQuery === true || (relationType === 'o2m' && parentAlias !== undefined)) {
+            let parent;
+            if (relationType === 'm2o') {
+                parent = relation.related_collection;
+            }
+            else if (relationType === 'a2o') {
+                const pathScope = pathParts[0].split(':')[1];
+                if (!pathScope) {
+                    throw new invalid_query_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+                }
+                parent = pathScope;
+            }
+            else {
+                parent = relation.collection;
+            }
+            pathParts.shift();
+            if (pathParts.length) {
+                followRelation(pathParts, parent, alias);
+            }
         }
     }
-    const relation = (_b = relations.find((relation) => {
-        var _a;
-        return ((relation.collection === collection && relation.field === field) ||
-            (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
-    })) !== null && _b !== void 0 ? _b : null;
-    const relationType = relation ? (0, get_relation_type_1.getRelationType)({ relation, collection, field }) : null;
-    return { relation, relationType };
 }
+function applySort(knex, schema, rootQuery, rootSort, collection, subQuery = false) {
+    const relations = schema.relations;
+    const aliasMap = {};
+    rootQuery.orderBy(rootSort.map((sortField) => {
+        const column = sortField.split('.');
+        let order = 'asc';
+        if (column.length > 1) {
+            if (sortField.startsWith('-')) {
+                order = 'desc';
+            }
+            if (column[0].startsWith('-')) {
+                column[0] = column[0].substring(1);
+            }
+            addJoin({
+                path: column,
+                collection,
+                aliasMap,
+                rootQuery,
+                subQuery,
+                schema,
+                relations,
+                knex,
+            });
+            const colPath = (0, get_column_path_1.getColumnPath)({ path: column, collection, aliasMap, relations }) || '';
+            const [alias, field] = colPath.split('.');
+            return {
+                order,
+                column: (0, get_column_1.getColumn)(knex, alias, field, false, schema),
+            };
+        }
+        let col = column[0];
+        if (sortField.startsWith('-')) {
+            col = column[0].substring(1);
+            order = 'desc';
+        }
+        return {
+            order,
+            column: (0, get_column_1.getColumn)(knex, collection, col, false, schema),
+        };
+    }));
+}
+exports.applySort = applySort;
 function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery = false) {
     const helpers = (0, helpers_1.getHelpers)(knex);
     const relations = schema.relations;
@@ -114,68 +169,16 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             }
             const filterPath = getFilterPath(key, value);
             if (filterPath.length > 1) {
-                addJoin(filterPath, collection);
-            }
-        }
-        function addJoin(path, collection) {
-            path = (0, lodash_1.clone)(path);
-            followRelation(path);
-            function followRelation(pathParts, parentCollection = collection, parentAlias) {
-                /**
-                 * 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 alias = generateAlias();
-                (0, lodash_1.set)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts, alias);
-                if (relationType === 'm2o') {
-                    dbQuery.leftJoin({ [alias]: relation.related_collection }, `${parentAlias || parentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
-                }
-                if (relationType === 'a2o') {
-                    const pathScope = pathParts[0].split(':')[1];
-                    if (!pathScope) {
-                        throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);
-                    }
-                    dbQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
-                        joinClause
-                            .onVal(relation.meta.one_collection_field, '=', pathScope)
-                            .andOn(`${parentAlias || parentCollection}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${alias}.${schema.collections[pathScope].primary}`));
-                    });
-                }
-                if (relationType === 'o2a') {
-                    dbQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
-                        joinClause
-                            .onVal(relation.meta.one_collection_field, '=', parentCollection)
-                            .andOn(`${alias}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${parentAlias || parentCollection}.${schema.collections[parentCollection].primary}`));
-                    });
-                }
-                // Still join o2m relations when in subquery OR when the o2m relation is not at the root level
-                if (relationType === 'o2m' && (subQuery === true || parentAlias !== undefined)) {
-                    dbQuery.leftJoin({ [alias]: relation.collection }, `${parentAlias || parentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
-                }
-                if (relationType === 'm2o' || subQuery === true || (relationType === 'o2m' && parentAlias !== undefined)) {
-                    let parent;
-                    if (relationType === 'm2o') {
-                        parent = relation.related_collection;
-                    }
-                    else if (relationType === 'a2o') {
-                        const pathScope = pathParts[0].split(':')[1];
-                        if (!pathScope) {
-                            throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);
-                        }
-                        parent = pathScope;
-                    }
-                    else {
-                        parent = relation.collection;
-                    }
-                    pathParts.shift();
-                    if (pathParts.length) {
-                        followRelation(pathParts, parent, alias);
-                    }
-                }
+                addJoin({
+                    path: filterPath,
+                    collection,
+                    knex,
+                    schema,
+                    relations,
+                    subQuery,
+                    rootQuery,
+                    aliasMap,
+                });
             }
         }
     }
@@ -201,11 +204,11 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
              * 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 { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, collection, pathRoot);
             const { operator: filterOperator, value: filterValue } = getOperation(key, value);
             if (relationType === 'm2o' || relationType === 'a2o' || relationType === null) {
                 if (filterPath.length > 1) {
-                    const columnName = getWhereColumn(filterPath, collection);
+                    const columnName = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
                     if (!columnName)
                         continue;
                     applyFilterToQuery(columnName, filterOperator, filterValue, logical);
@@ -311,24 +314,48 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             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);
             }
@@ -382,41 +409,6 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
             }
         }
-        function getWhereColumn(path, collection) {
-            return followRelation(path);
-            function followRelation(pathParts, parentCollection = collection, parentAlias) {
-                /**
-                 * 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) {
-                    throw new exceptions_1.InvalidQueryException(`"${parentCollection}.${pathRoot}" is not a relational field`);
-                }
-                const alias = (0, lodash_1.get)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts);
-                const remainingParts = pathParts.slice(1);
-                let parent;
-                if (relationType === 'a2o') {
-                    const pathScope = pathParts[0].split(':')[1];
-                    if (!pathScope) {
-                        throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);
-                    }
-                    parent = pathScope;
-                }
-                else if (relationType === 'm2o') {
-                    parent = relation.related_collection;
-                }
-                else {
-                    parent = relation.collection;
-                }
-                if (remainingParts.length === 1) {
-                    return `${alias || parent}.${remainingParts[0]}`;
-                }
-                if (remainingParts.length) {
-                    return followRelation(remainingParts, parent, alias);
-                }
-            }
-        }
     }
 }
 exports.applyFilter = applyFilter;
@@ -450,6 +442,9 @@ function applyAggregate(dbQuery, aggregate, collection) {
             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' });

package/dist/utils/apply-snapshot.d.ts

@@ -1,7 +1,7 @@
-import { Snapshot, SnapshotDiff, SnapshotField } from '../types';
-import { Knex } from 'knex';
-import { Diff } from 'deep-diff';
 import { SchemaOverview } from '@directus/shared/types';
+import { Diff } from 'deep-diff';
+import { Knex } from 'knex';
+import { Snapshot, SnapshotDiff, SnapshotField } from '../types';
 export declare function applySnapshot(snapshot: Snapshot, options?: {
     database?: Knex;
     schema?: SchemaOverview;