directus 9.11.0 → 9.11.1

package/dist/database/index.js

@@ -54,6 +54,11 @@ function getDatabase() {
                 requiredEnvVars.push('DB_CONNECTION_STRING');
             }
             break;
+        case 'mssql':
+            if (!env_1.default.DB_TYPE || env_1.default.DB_TYPE === 'default') {
+                requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD');
+            }
+            break;
         default:
             requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD');
     }

package/dist/database/system-data/fields/activity.yaml

@@ -37,6 +37,9 @@ fields:
 
   - field: timestamp
     display: datetime
+    special:
+      - date-created
+      - cast-timestamp
     options:
       relative: true
     width: half

package/dist/database/system-data/fields/dashboards.yaml

@@ -8,7 +8,9 @@ fields:
   - field: panels
     special: o2m
   - field: date_created
-    special: date-created
+    special:
+      - date-created
+      - cast-timestamp
   - field: user_created
     special: user-created
   - field: note

package/dist/database/system-data/fields/notifications.yaml

@@ -3,7 +3,9 @@ table: directus_notifications
 fields:
   - field: id
   - field: timestamp
-    special: date-created
+    special:
+      - date-created
+      - cast-timestamp
   - field: status
   - field: recipient
   - field: sender

package/dist/database/system-data/fields/panels.yaml

@@ -17,7 +17,9 @@ fields:
   - field: options
     special: cast-json
   - field: date_created
-    special: date-created
+    special:
+      - date-created
+      - cast-timestamp
   - field: user_created
     special: user-created
   - field: dashboard

package/dist/database/system-data/fields/shares.yaml

@@ -51,7 +51,9 @@ fields:
     readonly: true
 
   - field: date_created
-    special: date-created
+    special:
+      - date-created
+      - cast-timestamp
     width: half
     readonly: true
     conditions:

package/dist/env.js

@@ -15,6 +15,179 @@ const path_1 = __importDefault(require("path"));
 const require_yaml_1 = require("./utils/require-yaml");
 const utils_1 = require("@directus/shared/utils");
 const parse_json_1 = require("./utils/parse-json");
+// keeping this here for now to prevent a circular import to constants.ts
+const allowedEnvironmentVars = [
+    // general
+    'CONFIG_PATH',
+    'HOST',
+    'PORT',
+    'PUBLIC_URL',
+    'LOG_LEVEL',
+    'LOG_STYLE',
+    'MAX_PAYLOAD_SIZE',
+    'ROOT_REDIRECT',
+    'SERVE_APP',
+    'GRAPHQL_INTROSPECTION',
+    // server
+    'SERVER_KEEP_ALIVE_TIMEOUT',
+    'SERVER_HEADERS_TIMEOUT',
+    // database
+    'DB_CLIENT',
+    'DB_HOST',
+    'DB_PORT',
+    'DB_DATABASE',
+    'DB_USER',
+    'DB_PASSWORD',
+    'DB_FILENAME',
+    'DB_CONNECTION_STRING',
+    'DB_POOL_.+',
+    'DB_EXCLUDE_TABLES',
+    'DB_CHARSET',
+    'DB_VERSION',
+    // security
+    'KEY',
+    'SECRET',
+    'ACCESS_TOKEN_TTL',
+    'REFRESH_TOKEN_TTL',
+    'REFRESH_TOKEN_COOKIE_DOMAIN',
+    'REFRESH_TOKEN_COOKIE_SECURE',
+    'REFRESH_TOKEN_COOKIE_SAME_SITE',
+    'REFRESH_TOKEN_COOKIE_NAME',
+    'PASSWORD_RESET_URL_ALLOW_LIST',
+    'USER_INVITE_URL_ALLOW_LIST',
+    'IP_TRUST_PROXY',
+    'IP_CUSTOM_HEADER',
+    'ASSETS_CONTENT_SECURITY_POLICY',
+    'IMPORT_IP_DENY_LIST',
+    'CONTENT_SECURITY_POLICY_.+',
+    'HSTS_.+',
+    // hashing
+    'HASH_MEMORY_COST',
+    'HASH_LENGTH',
+    'HASH_TIME_COST',
+    'HASH_PARALLELISM',
+    'HASH_TYPE',
+    'HASH_ASSOCIATED_DATA',
+    // cors
+    'CORS_ENABLED',
+    'CORS_ORIGIN',
+    'CORS_METHODS',
+    'CORS_ALLOWED_HEADERS',
+    'CORS_EXPOSED_HEADERS',
+    'CORS_CREDENTIALS',
+    'CORS_MAX_AGE',
+    // rate limiting
+    'RATE_LIMITER_ENABLED',
+    'RATE_LIMITER_POINTS',
+    'RATE_LIMITER_DURATION',
+    'RATE_LIMITER_STORE',
+    'RATE_LIMITER_REDIS',
+    'RATE_LIMITER_REDIS_HOST',
+    'RATE_LIMITER_REDIS_PORT',
+    'RATE_LIMITER_REDIS_PASSWORD',
+    'RATE_LIMITER_MEMCACHE',
+    // cache
+    'CACHE_ENABLED',
+    'CACHE_TTL',
+    'CACHE_CONTROL_S_MAXAGE',
+    'CACHE_AUTO_PURGE',
+    'CACHE_SYSTEM_TTL',
+    'CACHE_SCHEMA',
+    'CACHE_PERMISSIONS',
+    'CACHE_NAMESPACE',
+    'CACHE_STORE',
+    'CACHE_STATUS_HEADER',
+    'CACHE_REDIS',
+    'CACHE_REDIS_HOST',
+    'CACHE_REDIS_PORT',
+    'CACHE_REDIS_PASSWORD',
+    'CACHE_MEMCACHE',
+    // storage
+    'STORAGE_LOCATIONS',
+    'STORAGE_.+_DRIVER',
+    'STORAGE_.+_ROOT',
+    'STORAGE_.+_KEY',
+    'STORAGE_.+_SECRET',
+    'STORAGE_.+_BUCKET',
+    'STORAGE_.+_REGION',
+    'STORAGE_.+_ENDPOINT',
+    'STORAGE_.+_ACL',
+    'STORAGE_.+_CONTAINER_NAME',
+    'STORAGE_.+_ACCOUNT_NAME',
+    'STORAGE_.+_ACCOUNT_KEY',
+    'STORAGE_.+_ENDPOINT',
+    'STORAGE_.+_KEY_FILENAME',
+    'STORAGE_.+_BUCKET',
+    // metadata
+    'FILE_METADATA_ALLOW_LIST',
+    // assets
+    'ASSETS_CACHE_TTL',
+    'ASSETS_TRANSFORM_MAX_CONCURRENT',
+    'ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION',
+    'ASSETS_TRANSFORM_MAX_OPERATIONS',
+    'ASSETS_CONTENT_SECURITY_POLICY',
+    // auth
+    'AUTH_PROVIDERS',
+    'AUTH_DISABLE_DEFAULT',
+    'AUTH_.+_DRIVER',
+    'AUTH_.+_CLIENT_ID',
+    'AUTH_.+_CLIENT_SECRET',
+    'AUTH_.+_SCOPE',
+    'AUTH_.+_AUTHORIZE_URL',
+    'AUTH_.+_ACCESS_URL',
+    'AUTH_.+_PROFILE_URL',
+    'AUTH_.+_IDENTIFIER_KEY',
+    'AUTH_.+_EMAIL_KEY',
+    'AUTH_.+_FIRST_NAME_KEY',
+    'AUTH_.+_LAST_NAME_KEY',
+    'AUTH_.+_ALLOW_PUBLIC_REGISTRATION',
+    'AUTH_.+_DEFAULT_ROLE_ID',
+    'AUTH_.+_ICON',
+    'AUTH_.+_PARAMS',
+    'AUTH_.+_ISSUER_URL',
+    'AUTH_.+_AUTH_REQUIRE_VERIFIED_EMAIL',
+    'AUTH_.+_CLIENT_URL',
+    'AUTH_.+_BIND_DN',
+    'AUTH_.+_BIND_PASSWORD',
+    'AUTH_.+_USER_DN',
+    'AUTH_.+_USER_ATTRIBUTE',
+    'AUTH_.+_USER_SCOPE',
+    'AUTH_.+_MAIL_ATTRIBUTE',
+    'AUTH_.+_FIRST_NAME_ATTRIBUTE',
+    'AUTH_.+_LAST_NAME_ATTRIBUTE',
+    'AUTH_.+_GROUP_DN',
+    'AUTH_.+_GROUP_ATTRIBUTE',
+    'AUTH_.+_GROUP_SCOPE',
+    // extensions
+    'EXTENSIONS_PATH',
+    'EXTENSIONS_AUTO_RELOAD',
+    // emails
+    'EMAIL_FROM',
+    'EMAIL_TRANSPORT',
+    'EMAIL_SENDMAIL_NEW_LINE',
+    'EMAIL_SENDMAIL_PATH',
+    'EMAIL_SMTP_HOST',
+    'EMAIL_SMTP_PORT',
+    'EMAIL_SMTP_USER',
+    'EMAIL_SMTP_PASSWORD',
+    'EMAIL_SMTP_POOL',
+    'EMAIL_SMTP_SECURE',
+    'EMAIL_SMTP_IGNORE_TLS',
+    'EMAIL_MAILGUN_API_KEY',
+    'EMAIL_MAILGUN_DOMAIN',
+    'EMAIL_MAILGUN_HOST',
+    'EMAIL_SES_CREDENTIALS__ACCESS_KEY_ID',
+    'EMAIL_SES_CREDENTIALS__SECRET_ACCESS_KEY',
+    'EMAIL_SES_REGION',
+    // admin account
+    'ADMIN_EMAIL',
+    'ADMIN_PASSWORD',
+    // telemetry
+    'TELEMETRY',
+    // limits & optimization
+    'RELATIONAL_BATCH_SIZE',
+    'EXPORT_BATCH_SIZE',
+].map((name) => new RegExp(`^${name}$`));
 const acceptedEnvTypes = ['string', 'number', 'regex', 'array', 'json'];
 const defaults = {
     CONFIG_PATH: path_1.default.resolve(process.cwd(), '.env'),
@@ -180,15 +353,17 @@ function processValues(env) {
         let newKey;
         if (key.length > 5 && key.endsWith('_FILE')) {
             newKey = key.slice(0, -5);
-            if (newKey in env) {
-                throw new Error(`Duplicate environment variable encountered: you can't use "${newKey}" and "${key}" simultaneously.`);
-            }
-            try {
-                value = fs_1.default.readFileSync(value, { encoding: 'utf8' });
-                key = newKey;
-            }
-            catch {
-                throw new Error(`Failed to read value from file "${value}", defined in environment variable "${key}".`);
+            if (allowedEnvironmentVars.some((pattern) => pattern.test(newKey))) {
+                if (newKey in env) {
+                    throw new Error(`Duplicate environment variable encountered: you can't use "${newKey}" and "${key}" simultaneously.`);
+                }
+                try {
+                    value = fs_1.default.readFileSync(value, { encoding: 'utf8' });
+                    key = newKey;
+                }
+                catch {
+                    throw new Error(`Failed to read value from file "${value}", defined in environment variable "${key}".`);
+                }
             }
         }
         // Convert values with a type prefix
@@ -213,7 +388,7 @@ function processValues(env) {
                     env[key] = tryJSON(value);
                     break;
                 case 'boolean':
-                    env[key] = value === 'true' || value === true || value === '1' || value === 1;
+                    env[key] = toBoolean(value);
             }
             continue;
         }
@@ -262,3 +437,6 @@ function tryJSON(value) {
         return value;
     }
 }
+function toBoolean(value) {
+    return value === 'true' || value === true || value === '1' || value === 1;
+}

package/dist/services/items.js

@@ -17,6 +17,7 @@ const get_ast_from_query_1 = __importDefault(require("../utils/get-ast-from-quer
 const authorization_1 = require("./authorization");
 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;
@@ -244,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);
@@ -258,6 +260,7 @@ 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
@@ -272,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;
     }
@@ -286,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)
@@ -415,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)
@@ -455,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;
     }
@@ -469,6 +484,7 @@ 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,

package/dist/utils/{apply-query/index.js → apply-query.js}

@@ -7,12 +7,12 @@ exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.app
 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 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 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);
 /**
  * Apply the Query to a given Knex query builder instance
@@ -155,9 +155,6 @@ 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') {
@@ -185,33 +182,8 @@ 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
@@ -252,12 +224,24 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 if (relationType === 'o2a') {
                     pkField = knex.raw(`CAST(?? AS CHAR(255))`, [pkField]);
                 }
-                if (isNegativeOperator(filterOperator)) {
-                    inverseFilters(value);
-                    dbQuery[logical].whereNotExists(callbackSubqueryRelation(relation, value));
+                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]));
                 }
                 else {
-                    dbQuery[logical].whereExists(callbackSubqueryRelation(relation, value));
+                    dbQuery[logical].whereIn(pkField, subQueryBuilder(value));
                 }
             }
         }
@@ -267,6 +251,32 @@ 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;
@@ -298,16 +308,105 @@ 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 in operators_1.default) {
-                operators_1.default[operator].apply({
-                    query: dbQuery[logical],
-                    helpers,
-                    selectionRaw,
-                    compareValue,
-                });
+            if (operator === '_eq') {
+                dbQuery[logical].where(selectionRaw, '=', compareValue);
             }
-            else {
-                throw new Error(`Operator ${operator} not supported`);
+            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') {
+                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 == '_nintersects_bbox') {
+                dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
             }
         }
     }

package/dist/utils/validate-keys.d.ts

@@ -0,0 +1,6 @@
+import { SchemaOverview } from '@directus/shared/types';
+import { PrimaryKey } from '../types';
+/**
+ * Validate keys based on its type
+ */
+export declare function validateKeys(schema: SchemaOverview, collection: string, keyField: string, keys: PrimaryKey | PrimaryKey[]): void;

package/dist/utils/validate-keys.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateKeys = void 0;
+const exceptions_1 = require("../exceptions");
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
+/**
+ * Validate keys based on its type
+ */
+function validateKeys(schema, collection, keyField, keys) {
+    if (Array.isArray(keys)) {
+        for (const key of keys) {
+            validateKeys(schema, collection, keyField, key);
+        }
+    }
+    else {
+        const primaryKeyFieldType = schema.collections[collection].fields[keyField].type;
+        if (primaryKeyFieldType === 'uuid' && !(0, uuid_validate_1.default)(String(keys))) {
+            throw new exceptions_1.ForbiddenException();
+        }
+        else if (primaryKeyFieldType === 'integer' && !Number.isInteger(Number(keys))) {
+            throw new exceptions_1.ForbiddenException();
+        }
+    }
+}
+exports.validateKeys = validateKeys;

package/dist/utils/validate-query.js

@@ -104,7 +104,7 @@ function validateFilterPrimitive(value, key) {
         false) {
         throw new exceptions_1.InvalidQueryException(`The filter value for "${key}" has to be a string, number, or boolean`);
     }
-    if (typeof value === 'number' && (Number.isNaN(value) || !Number.isSafeInteger(value))) {
+    if (typeof value === 'number' && Number.isNaN(value) && value <= Number.MAX_SAFE_INTEGER) {
         throw new exceptions_1.InvalidQueryException(`The filter value for "${key}" is not a valid number`);
     }
     if (typeof value === 'string' && value.length === 0) {