directus 9.10.0 → 9.11.0

package/dist/services/fields.js

@@ -351,13 +351,6 @@ class FieldsService {
             });
             await this.knex.transaction(async (trx) => {
                 var _a, _b;
-                if (this.schema.collections[collection] &&
-                    field in this.schema.collections[collection].fields &&
-                    this.schema.collections[collection].fields[field].alias === false) {
-                    await trx.schema.table(collection, (table) => {
-                        table.dropColumn(field);
-                    });
-                }
                 const relations = this.schema.relations.filter((relation) => {
                     var _a;
                     return ((relation.collection === collection && relation.field === field) ||
@@ -389,6 +382,14 @@ class FieldsService {
                             .where({ many_collection: relation.collection, many_field: relation.field });
                     }
                 }
+                // Delete field only after foreign key constraints are removed
+                if (this.schema.collections[collection] &&
+                    field in this.schema.collections[collection].fields &&
+                    this.schema.collections[collection].fields[field].alias === false) {
+                    await trx.schema.table(collection, (table) => {
+                        table.dropColumn(field);
+                    });
+                }
                 const collectionMeta = await trx
                     .select('archive_field', 'sort_field')
                     .from('directus_collections')
@@ -441,7 +442,13 @@ class FieldsService {
         if (field.type === 'alias' || field.type === 'unknown')
             return;
         if ((_a = field.schema) === null || _a === void 0 ? void 0 : _a.has_auto_increment) {
-            column = table.increments(field.field);
+            if (field.type === 'bigInteger') {
+                // Create an auto-incremented big integer (MySQL, PostgreSQL) or an auto-incremented integer (other DBs)
+                column = table.bigIncrements(field.field);
+            }
+            else {
+                column = table.increments(field.field);
+            }
         }
         else if (field.type === 'string') {
             column = table.string(field.field, (_c = (_b = field.schema) === null || _b === void 0 ? void 0 : _b.max_length) !== null && _c !== void 0 ? _c : undefined);

package/dist/services/graphql.js

@@ -170,16 +170,7 @@ class GraphQLService {
                 acc[collectionName] = ReadCollectionTypes[collection.collection].getResolver(collection.collection);
                 if (this.schema.collections[collection.collection].singleton === false) {
                     acc[`${collectionName}_by_id`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_by_id`);
-                    const hasAggregate = Object.values(collection.fields).some((field) => {
-                        const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type);
-                        if (graphqlType === graphql_1.GraphQLInt || graphqlType === graphql_1.GraphQLFloat) {
-                            return true;
-                        }
-                        return false;
-                    });
-                    if (hasAggregate) {
-                        acc[`${collectionName}_aggregated`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_aggregated`);
-                    }
+                    acc[`${collectionName}_aggregated`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_aggregated`);
                 }
                 return acc;
             }, {}));
@@ -424,7 +415,8 @@ class GraphQLService {
             const { CollectionTypes: ReadCollectionTypes } = getTypes('read');
             const ReadableCollectionFilterTypes = {};
             const AggregatedFunctions = {};
-            const AggregatedFilters = {};
+            const AggregatedFields = {};
+            const AggregateMethods = {};
             const StringFilterOperators = schemaComposer.createInputTC({
                 name: 'string_filter_operators',
                 fields: {
@@ -680,7 +672,7 @@ class GraphQLService {
                     _and: [ReadableCollectionFilterTypes[collection.collection]],
                     _or: [ReadableCollectionFilterTypes[collection.collection]],
                 });
-                AggregatedFilters[collection.collection] = schemaComposer.createObjectTC({
+                AggregatedFields[collection.collection] = schemaComposer.createObjectTC({
                     name: `${collection.collection}_aggregated_fields`,
                     fields: Object.values(collection.fields).reduce((acc, field) => {
                         const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type);
@@ -698,46 +690,71 @@ class GraphQLService {
                         return acc;
                     }, {}),
                 });
-                AggregatedFunctions[collection.collection] = schemaComposer.createObjectTC({
-                    name: `${collection.collection}_aggregated`,
-                    fields: {
-                        group: {
-                            name: 'group',
-                            type: graphql_compose_1.GraphQLJSON,
-                        },
+                AggregateMethods[collection.collection] = {
+                    group: {
+                        name: 'group',
+                        type: graphql_compose_1.GraphQLJSON,
+                    },
+                    countAll: {
+                        name: 'countAll',
+                        type: graphql_1.GraphQLInt,
+                    },
+                    count: {
+                        name: 'count',
+                        type: schemaComposer.createObjectTC({
+                            name: `${collection.collection}_aggregated_count`,
+                            fields: Object.values(collection.fields).reduce((acc, field) => {
+                                acc[field.field] = {
+                                    type: graphql_1.GraphQLInt,
+                                    description: field.note,
+                                };
+                                return acc;
+                            }, {}),
+                        }),
+                    },
+                };
+                const hasNumericAggregates = Object.values(collection.fields).some((field) => {
+                    const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type);
+                    if (graphqlType === graphql_1.GraphQLInt || graphqlType === graphql_1.GraphQLFloat) {
+                        return true;
+                    }
+                    return false;
+                });
+                if (hasNumericAggregates) {
+                    Object.assign(AggregateMethods[collection.collection], {
                         avg: {
                             name: 'avg',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         sum: {
                             name: 'sum',
-                            type: AggregatedFilters[collection.collection],
-                        },
-                        count: {
-                            name: 'count',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         countDistinct: {
                             name: 'countDistinct',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         avgDistinct: {
                             name: 'avgDistinct',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         sumDistinct: {
                             name: 'sumDistinct',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         min: {
                             name: 'min',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         max: {
                             name: 'max',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
-                    },
+                    });
+                }
+                AggregatedFunctions[collection.collection] = schemaComposer.createObjectTC({
+                    name: `${collection.collection}_aggregated`,
+                    fields: AggregateMethods[collection.collection],
                 });
                 ReadCollectionTypes[collection.collection].addResolver({
                     name: collection.collection,
@@ -1237,7 +1254,7 @@ class GraphQLService {
                         if (!query.deep)
                             query.deep = {};
                         const args = this.parseArgs(selection.arguments, variableValues);
-                        (0, lodash_1.set)(query.deep, current, (0, lodash_1.merge)((0, lodash_1.get)(query.deep, current), (0, lodash_1.mapKeys)((0, sanitize_query_1.sanitizeQuery)(args, this.accountability), (value, key) => `_${key}`)));
+                        (0, lodash_1.set)(query.deep, currentAlias !== null && currentAlias !== void 0 ? currentAlias : current, (0, lodash_1.merge)((0, lodash_1.get)(query.deep, currentAlias !== null && currentAlias !== void 0 ? currentAlias : current), (0, lodash_1.mapKeys)((0, sanitize_query_1.sanitizeQuery)(args, this.accountability), (value, key) => `_${key}`)));
                     }
                 }
             }

package/dist/services/import-export.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
+import { Accountability, Query, SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
 import { AbstractServiceOptions, File } from '../types';
-import { Accountability, Query, SchemaOverview } from '@directus/shared/types';
 export declare class ImportService {
     knex: Knex;
     accountability: Accountability | null;

package/dist/services/import-export.js

@@ -4,25 +4,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportService = exports.ImportService = void 0;
-const database_1 = __importDefault(require("../database"));
-const exceptions_1 = require("../exceptions");
-const StreamArray_1 = __importDefault(require("stream-json/streamers/StreamArray"));
-const items_1 = require("./items");
+const utils_1 = require("@directus/shared/utils");
 const async_1 = require("async");
-const destroy_1 = __importDefault(require("destroy"));
 const csv_parser_1 = __importDefault(require("csv-parser"));
-const lodash_1 = require("lodash");
+const destroy_1 = __importDefault(require("destroy"));
+const fs_extra_1 = require("fs-extra");
 const js2xmlparser_1 = require("js2xmlparser");
 const json2csv_1 = require("json2csv");
-const fs_extra_1 = require("fs-extra");
+const lodash_1 = require("lodash");
+const StreamArray_1 = __importDefault(require("stream-json/streamers/StreamArray"));
+const strip_bom_stream_1 = __importDefault(require("strip-bom-stream"));
 const tmp_promise_1 = require("tmp-promise");
+const database_1 = __importDefault(require("../database"));
 const env_1 = __importDefault(require("../env"));
-const files_1 = require("./files");
+const exceptions_1 = require("../exceptions");
+const logger_1 = __importDefault(require("../logger"));
 const get_date_formatted_1 = require("../utils/get-date-formatted");
-const utils_1 = require("@directus/shared/utils");
+const parse_json_1 = require("../utils/parse-json");
+const files_1 = require("./files");
+const items_1 = require("./items");
 const notifications_1 = require("./notifications");
-const logger_1 = __importDefault(require("../logger"));
-const strip_bom_stream_1 = __importDefault(require("strip-bom-stream"));
 class ImportService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
@@ -101,7 +102,7 @@ class ImportService {
                         }
                         else {
                             try {
-                                const parsedJson = JSON.parse(value);
+                                const parsedJson = (0, parse_json_1.parseJSON)(value);
                                 (0, lodash_1.set)(result, key, parsedJson);
                             }
                             catch {

package/dist/services/items.d.ts

@@ -1,7 +1,7 @@
-import { Knex } from 'knex';
+import { Accountability, PermissionsAction, Query, SchemaOverview } from '@directus/shared/types';
 import Keyv from 'keyv';
-import { Accountability, Query, PermissionsAction, SchemaOverview } from '@directus/shared/types';
-import { AbstractService, AbstractServiceOptions, Item as AnyItem, PrimaryKey, MutationOptions } from '../types';
+import { Knex } from 'knex';
+import { AbstractService, AbstractServiceOptions, Item as AnyItem, MutationOptions, PrimaryKey } from '../types';
 export declare type QueryOptions = {
     stripNonRequested?: boolean;
     permissionsAction?: PermissionsAction;

package/dist/services/items.js

@@ -15,8 +15,8 @@ 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");
 class ItemsService {
     constructor(collection, options) {
         this.collection = collection;
@@ -260,6 +260,10 @@ class ItemsService {
         const primaryKeyField = this.schema.collections[this.collection].primary;
         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;
     }
@@ -306,6 +310,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);
         }
@@ -467,6 +473,7 @@ class ItemsService {
             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) {

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.js → apply-query/index.js}

@@ -4,15 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.applySort = void 0;
-const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
-const helpers_1 = require("../database/helpers");
-const exceptions_1 = require("../exceptions");
-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 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 operators_1 = __importDefault(require("./operators"));
 const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
 /**
  * Apply the Query to a given Knex query builder instance
@@ -65,7 +65,7 @@ function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, rela
         if (relationType === 'a2o') {
             const pathScope = pathParts[0].split(':')[1];
             if (!pathScope) {
-                throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+                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
@@ -92,7 +92,7 @@ function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, rela
             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 sorting or filtering on a many-to-any item`);
+                    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;
             }
@@ -155,6 +155,9 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
     addJoins(rootQuery, rootFilter, collection);
     addWhereClauses(knex, rootQuery, rootFilter, collection);
     return rootQuery;
+    function isNegativeOperator(operator) {
+        return operator.indexOf('_n') === 0;
+    }
     function addJoins(dbQuery, filter, collection) {
         for (const [key, value] of Object.entries(filter)) {
             if (key === '_or' || key === '_and') {
@@ -182,8 +185,33 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             }
         }
     }
+    function callbackSubqueryRelation(relation, value) {
+        return function (subQueryKnex) {
+            const field = relation.field;
+            const collection = relation.collection;
+            const column = `${collection}.${field}`;
+            subQueryKnex.from(collection).whereRaw(`${field} = ${column}`);
+            applyQuery(knex, relation.collection, subQueryKnex, {
+                filter: value,
+            }, schema, true);
+        };
+    }
+    function inverseFilters(value) {
+        for (const field in value) {
+            for (const operator in value[field]) {
+                let inverseOperator = operator;
+                if (isNegativeOperator(operator)) {
+                    inverseOperator = '_' + operator.substring(2);
+                }
+                else {
+                    inverseOperator = '_n' + operator.substring(1);
+                }
+                value[field][inverseOperator] = value[field][operator];
+                delete value[field][operator];
+            }
+        }
+    }
     function addWhereClauses(knex, dbQuery, filter, collection, logical = 'and') {
-        var _a, _b;
         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
@@ -224,24 +252,12 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 if (relationType === 'o2a') {
                     pkField = knex.raw(`CAST(?? AS CHAR(255))`, [pkField]);
                 }
-                const subQueryBuilder = (filter) => (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, true);
-                };
-                if (((_a = Object.keys(value)) === null || _a === void 0 ? void 0 : _a[0]) === '_none') {
-                    dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0]));
-                }
-                else if (((_b = Object.keys(value)) === null || _b === void 0 ? void 0 : _b[0]) === '_some') {
-                    dbQuery[logical].whereIn(pkField, subQueryBuilder(Object.values(value)[0]));
+                if (isNegativeOperator(filterOperator)) {
+                    inverseFilters(value);
+                    dbQuery[logical].whereNotExists(callbackSubqueryRelation(relation, value));
                 }
                 else {
-                    dbQuery[logical].whereIn(pkField, subQueryBuilder(value));
+                    dbQuery[logical].whereExists(callbackSubqueryRelation(relation, value));
                 }
             }
         }
@@ -251,32 +267,6 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             const selectionRaw = (0, get_column_1.getColumn)(knex, table, column, false, schema);
             // 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' || (operator === '_nnull' && compareValue === false)) {
-                dbQuery[logical].whereNull(selectionRaw);
-            }
-            if (operator === '_nnull' || (operator === '_null' && compareValue === false)) {
-                dbQuery[logical].whereNotNull(selectionRaw);
-            }
-            if (operator === '_empty' || (operator === '_nempty' && compareValue === false)) {
-                dbQuery[logical].andWhere((query) => {
-                    query.where(key, '=', '');
-                });
-            }
-            if (operator === '_nempty' || (operator === '_empty' && compareValue === false)) {
-                dbQuery[logical].andWhere((query) => {
-                    query.where(key, '!=', '');
-                });
-            }
-            // Cast filter value (compareValue) based on function used
-            if (column.includes('(') && column.includes(')')) {
-                const functionName = column.split('(')[0];
-                const type = (0, utils_1.getOutputTypeForFunction)(functionName);
-                if (['bigInteger', 'integer', 'float', 'decimal'].includes(type)) {
-                    compareValue = Number(compareValue);
-                }
-            }
-            // Cast filter value (compareValue) based on type of field being filtered against
             const [collection, field] = key.split('.');
             if (collection in schema.collections && field in schema.collections[collection].fields) {
                 const type = schema.collections[collection].fields[field].type;
@@ -308,81 +298,16 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 // We need to remove any undefined values, as they are useless
                 compareValue = compareValue.filter((val) => val !== undefined);
             }
-            if (operator === '_eq') {
-                dbQuery[logical].where(selectionRaw, '=', compareValue);
-            }
-            if (operator === '_neq') {
-                dbQuery[logical].whereNot(selectionRaw, compareValue);
-            }
-            if (operator === '_contains') {
-                dbQuery[logical].where(selectionRaw, 'like', `%${compareValue}%`);
-            }
-            if (operator === '_ncontains') {
-                dbQuery[logical].whereNot(selectionRaw, 'like', `%${compareValue}%`);
-            }
-            if (operator === '_starts_with') {
-                dbQuery[logical].where(key, 'like', `${compareValue}%`);
-            }
-            if (operator === '_nstarts_with') {
-                dbQuery[logical].whereNot(key, 'like', `${compareValue}%`);
-            }
-            if (operator === '_ends_with') {
-                dbQuery[logical].where(key, 'like', `%${compareValue}`);
-            }
-            if (operator === '_nends_with') {
-                dbQuery[logical].whereNot(key, 'like', `%${compareValue}`);
-            }
-            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') {
-                if (compareValue.length !== 2)
-                    return;
-                let value = compareValue;
-                if (typeof value === 'string')
-                    value = value.split(',');
-                dbQuery[logical].whereBetween(selectionRaw, value);
-            }
-            if (operator === '_nbetween') {
-                if (compareValue.length !== 2)
-                    return;
-                let value = compareValue;
-                if (typeof value === 'string')
-                    value = value.split(',');
-                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 in operators_1.default) {
+                operators_1.default[operator].apply({
+                    query: dbQuery[logical],
+                    helpers,
+                    selectionRaw,
+                    compareValue,
+                });
             }
-            if (operator == '_nintersects_bbox') {
-                dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
+            else {
+                throw new Error(`Operator ${operator} not supported`);
             }
         }
     }
@@ -418,6 +343,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-query/operators/between.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;