directus 9.7.1 → 9.9.1

package/dist/utils/apply-query.js

@@ -11,6 +11,7 @@ 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 utils_1 = require("@directus/shared/utils");
 const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
 /**
  * Apply the Query to a given Knex query builder instance
@@ -26,7 +27,7 @@ function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false)
             }
             return {
                 order,
-                column: (0, get_column_1.getColumn)(knex, collection, column, false),
+                column: (0, get_column_1.getColumn)(knex, collection, column, false, schema),
             };
         }));
     }
@@ -43,7 +44,7 @@ function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false)
         applySearch(schema, dbQuery, query.search, collection);
     }
     if (query.group) {
-        dbQuery.groupBy(query.group.map((column) => (0, get_column_1.getColumn)(knex, collection, column, false)));
+        dbQuery.groupBy(query.group.map((column) => (0, get_column_1.getColumn)(knex, collection, column, false, schema)));
     }
     if (query.aggregate) {
         applyAggregate(dbQuery, query.aggregate, collection);
@@ -179,6 +180,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
         }
     }
     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
@@ -219,22 +221,31 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 if (relationType === 'o2a') {
                     pkField = knex.raw(`CAST(?? AS CHAR(255))`, [pkField]);
                 }
-                // Note: knex's types don't appreciate knex.raw in whereIn, even though it's officially supported
-                dbQuery[logical].whereIn(pkField, (subQueryKnex) => {
+                const subQueryBuilder = (filter) => (subQueryKnex) => {
                     const field = relation.field;
                     const collection = relation.collection;
                     const column = `${collection}.${field}`;
-                    subQueryKnex.select({ [field]: column }).from(collection);
-                    applyQuery(knex, relation.collection, subQueryKnex, {
-                        filter: value,
-                    }, schema, true);
-                });
+                    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].whereIn(pkField, subQueryBuilder(value));
+                }
             }
         }
         function applyFilterToQuery(key, operator, compareValue, logical = 'and') {
             const [table, column] = key.split('.');
             // Is processed through Knex.Raw, so should be safe to string-inject into these where queries
-            const selectionRaw = (0, get_column_1.getColumn)(knex, table, column, false);
+            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]`)
@@ -254,6 +265,15 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                     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;
@@ -265,6 +285,14 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                         compareValue = helpers.date.parse(compareValue);
                     }
                 }
+                if (['bigInteger', 'integer', 'float', 'decimal'].includes(type)) {
+                    if (Array.isArray(compareValue)) {
+                        compareValue = compareValue.map((val) => Number(val));
+                    }
+                    else {
+                        compareValue = Number(compareValue);
+                    }
+                }
             }
             // The following fields however, require a value to be run. If no value is passed, we
             // ignore them. This allows easier use in GraphQL, where you wouldn't be able to

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

@@ -1,5 +1,6 @@
-import { Snapshot, SnapshotDiff } from '../types';
+import { Snapshot, SnapshotDiff, SnapshotField } from '../types';
 import { Knex } from 'knex';
+import { Diff } from 'deep-diff';
 import { SchemaOverview } from '@directus/shared/types';
 export declare function applySnapshot(snapshot: Snapshot, options?: {
     database?: Knex;
@@ -7,3 +8,4 @@ export declare function applySnapshot(snapshot: Snapshot, options?: {
     current?: Snapshot;
     diff?: SnapshotDiff;
 }): Promise<void>;
+export declare function isNestedMetaUpdate(diff: Diff<SnapshotField | undefined>): boolean;

package/dist/utils/apply-snapshot.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applySnapshot = void 0;
+exports.isNestedMetaUpdate = exports.applySnapshot = void 0;
 const get_snapshot_1 = require("./get-snapshot");
 const get_snapshot_diff_1 = require("./get-snapshot-diff");
 const database_1 = __importDefault(require("../database"));
@@ -34,7 +34,26 @@ async function applySnapshot(snapshot, options) {
                 // creating a collection without a primary key
                 const fields = snapshotDiff.fields
                     .filter((fieldDiff) => fieldDiff.collection === collection)
-                    .map((fieldDiff) => fieldDiff.diff[0].rhs);
+                    .map((fieldDiff) => fieldDiff.diff[0].rhs)
+                    .map((fieldDiff) => {
+                    // Casts field type to UUID when applying SQLite-based schema on other databases.
+                    // This is needed because SQLite snapshots UUID fields as char with length 36, and
+                    // it will fail when trying to create relation between char field to UUID field
+                    if (!fieldDiff.schema ||
+                        fieldDiff.schema.data_type !== 'char' ||
+                        fieldDiff.schema.max_length !== 36 ||
+                        !fieldDiff.schema.foreign_key_table ||
+                        !fieldDiff.schema.foreign_key_column) {
+                        return fieldDiff;
+                    }
+                    const matchingForeignKeyTable = schema.collections[fieldDiff.schema.foreign_key_table];
+                    if (!matchingForeignKeyTable)
+                        return fieldDiff;
+                    const matchingForeignKeyField = matchingForeignKeyTable.fields[fieldDiff.schema.foreign_key_column];
+                    if (!matchingForeignKeyField || matchingForeignKeyField.type !== 'uuid')
+                        return fieldDiff;
+                    return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
+                });
                 try {
                     await collectionsService.createOne({
                         ...diff[0].rhs,
@@ -66,7 +85,7 @@ async function applySnapshot(snapshot, options) {
         }
         const fieldsService = new services_1.FieldsService({ knex: trx, schema: await (0, get_schema_1.getSchema)({ database: trx }) });
         for (const { collection, field, diff } of snapshotDiff.fields) {
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N') {
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N' && !isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
                 try {
                     await fieldsService.createField(collection, diff[0].rhs);
                 }
@@ -75,7 +94,7 @@ async function applySnapshot(snapshot, options) {
                     throw err;
                 }
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A') {
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A' || isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
                 const newValues = snapshot.fields.find((snapshotField) => {
                     return snapshotField.collection === collection && snapshotField.field === field;
                 });
@@ -91,7 +110,7 @@ async function applySnapshot(snapshot, options) {
                     }
                 }
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
+            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D' && !isNestedMetaUpdate(diff === null || diff === void 0 ? void 0 : diff[0])) {
                 try {
                     await fieldsService.deleteField(collection, field);
                 }
@@ -146,3 +165,13 @@ async function applySnapshot(snapshot, options) {
     });
 }
 exports.applySnapshot = applySnapshot;
+function isNestedMetaUpdate(diff) {
+    if (!diff)
+        return false;
+    if (diff.kind !== 'N' && diff.kind !== 'D')
+        return false;
+    if (!diff.path || diff.path.length < 2 || diff.path[0] !== 'meta')
+        return false;
+    return true;
+}
+exports.isNestedMetaUpdate = isNestedMetaUpdate;

package/dist/utils/get-ast-from-query.js

@@ -75,9 +75,17 @@ async function getASTFromQuery(collection, query, schema, options) {
         const relationalStructure = {};
         for (const fieldKey of fields) {
             let name = fieldKey;
-            const isAlias = (_a = (query.alias && name in query.alias)) !== null && _a !== void 0 ? _a : false;
-            if (isAlias) {
-                name = query.alias[fieldKey];
+            if (query.alias) {
+                // check for field alias (is is one of the key)
+                if (name in query.alias) {
+                    name = query.alias[fieldKey];
+                }
+                // check for junction alias (it is one of the value instead of the key)
+                if (Object.values(query.alias).includes(name)) {
+                    const aliasKey = Object.keys(query.alias).find((key) => { var _a; return ((_a = query.alias) === null || _a === void 0 ? void 0 : _a[key]) === name; });
+                    if (aliasKey && fieldKey !== aliasKey)
+                        name = aliasKey;
+                }
             }
             const isRelational = name.includes('.') ||
                 // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
@@ -162,6 +170,10 @@ async function getASTFromQuery(collection, query, schema, options) {
                 if (permissions && permissions.some((permission) => permission.collection === relatedCollection) === false) {
                     continue;
                 }
+                // update query alias for children parseFields
+                const deepAlias = (_a = getDeepQuery((deep === null || deep === void 0 ? void 0 : deep[fieldKey]) || {})) === null || _a === void 0 ? void 0 : _a.alias;
+                if (!(0, lodash_1.isEmpty)(deepAlias))
+                    query.alias = deepAlias;
                 child = {
                     type: relationType,
                     name: relatedCollection,

package/dist/utils/get-column.d.ts

@@ -1,12 +1,13 @@
+import { SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
 /**
- * Return column prefixed by table. If column includes functions (like `year(date_created)`, the
- * column is replaced with the appropriate SQL)
+ * Return column prefixed by table. If column includes functions (like `year(date_created)`), the
+ * column is replaced with the appropriate SQL
  *
  * @param knex Current knex / transaction instance
- * @param collection Collection or alias in which column resides
- * @param field name of the column
+ * @param table Collection or alias in which column resides
+ * @param column name of the column
  * @param alias Whether or not to add a SQL AS statement
  * @returns Knex raw instance
  */
-export declare function getColumn(knex: Knex, table: string, column: string, alias?: string | false): Knex.Raw;
+export declare function getColumn(knex: Knex, table: string, column: string, alias: string | false | undefined, schema: SchemaOverview): Knex.Raw;

package/dist/utils/get-column.js

@@ -1,25 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getColumn = void 0;
-const helpers_1 = require("../database/helpers");
 const constants_1 = require("@directus/shared/constants");
+const utils_1 = require("@directus/shared/utils");
+const helpers_1 = require("../database/helpers");
+const exceptions_1 = require("../exceptions");
 const apply_function_to_column_name_1 = require("./apply-function-to-column-name");
 /**
- * Return column prefixed by table. If column includes functions (like `year(date_created)`, the
- * column is replaced with the appropriate SQL)
+ * Return column prefixed by table. If column includes functions (like `year(date_created)`), the
+ * column is replaced with the appropriate SQL
  *
  * @param knex Current knex / transaction instance
- * @param collection Collection or alias in which column resides
- * @param field name of the column
+ * @param table Collection or alias in which column resides
+ * @param column name of the column
  * @param alias Whether or not to add a SQL AS statement
  * @returns Knex raw instance
  */
-function getColumn(knex, table, column, alias = (0, apply_function_to_column_name_1.applyFunctionToColumnName)(column)) {
-    const { date: fn } = (0, helpers_1.getHelpers)(knex);
+function getColumn(knex, table, column, alias = (0, apply_function_to_column_name_1.applyFunctionToColumnName)(column), schema) {
+    var _a, _b, _c, _d;
+    const fn = (0, helpers_1.getFunctions)(knex, schema);
     if (column.includes('(') && column.includes(')')) {
         const functionName = column.split('(')[0];
         const columnName = column.match(constants_1.REGEX_BETWEEN_PARENS)[1];
         if (functionName in fn) {
+            const type = (_d = (_c = (_b = (_a = schema === null || schema === void 0 ? void 0 : schema.collections[table]) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b[columnName]) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : 'unknown';
+            const allowedFunctions = (0, utils_1.getFunctionsForType)(type);
+            if (allowedFunctions.includes(functionName) === false) {
+                throw new exceptions_1.InvalidQueryException(`Invalid function specified "${functionName}"`);
+            }
             const result = fn[functionName](table, columnName);
             if (alias) {
                 return knex.raw(result + ' AS ??', [alias]);
@@ -27,7 +35,7 @@ function getColumn(knex, table, column, alias = (0, apply_function_to_column_nam
             return result;
         }
         else {
-            throw new Error(`Invalid function specified "${functionName}"`);
+            throw new exceptions_1.InvalidQueryException(`Invalid function specified "${functionName}"`);
         }
     }
     if (alias && column !== alias) {

package/dist/utils/get-graphql-type.js

@@ -9,6 +9,7 @@ function getGraphQLType(localType) {
         case 'boolean':
             return graphql_1.GraphQLBoolean;
         case 'bigInteger':
+            return graphql_1.GraphQLString;
         case 'integer':
             return graphql_1.GraphQLInt;
         case 'decimal':

package/dist/utils/get-local-type.js

@@ -88,6 +88,7 @@ const localTypeMap = {
     'time without time zone': 'time',
     float4: 'float',
     float8: 'float',
+    citext: 'text',
     // Oracle
     number: 'integer',
     sdo_geometry: 'geometry',
@@ -109,6 +110,10 @@ function getLocalType(column, field) {
             return 'csv';
         if (special.includes('uuid') || special.includes('file'))
             return 'uuid';
+        if (special.includes('cast-timestamp'))
+            return 'timestamp';
+        if (special.includes('cast-datetime'))
+            return 'dateTime';
         if (type === null || type === void 0 ? void 0 : type.startsWith('geometry')) {
             return special[0] || 'geometry';
         }

package/dist/utils/get-schema.d.ts

@@ -1,5 +1,5 @@
-import { Knex } from 'knex';
 import { Accountability, SchemaOverview } from '@directus/shared/types';
+import { Knex } from 'knex';
 export declare function getSchema(options?: {
     accountability?: Accountability;
     database?: Knex;

package/dist/utils/get-schema.js

@@ -5,17 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSchema = void 0;
 const schema_1 = __importDefault(require("@directus/schema"));
+const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
+const cache_1 = require("../cache");
+const constants_1 = require("../constants");
+const database_1 = __importDefault(require("../database"));
 const collections_1 = require("../database/system-data/collections");
 const fields_1 = require("../database/system-data/fields");
+const env_1 = __importDefault(require("../env"));
 const logger_1 = __importDefault(require("../logger"));
 const services_1 = require("../services");
-const utils_1 = require("@directus/shared/utils");
 const get_default_value_1 = __importDefault(require("./get-default-value"));
 const get_local_type_1 = __importDefault(require("./get-local-type"));
-const database_1 = __importDefault(require("../database"));
-const cache_1 = require("../cache");
-const env_1 = __importDefault(require("../env"));
 async function getSchema(options) {
     const database = (options === null || options === void 0 ? void 0 : options.database) || (0, database_1.default)();
     const schemaInspector = (0, schema_1.default)(database);
@@ -49,7 +50,7 @@ async function getSchema(options) {
 }
 exports.getSchema = getSchema;
 async function getDatabaseSchema(database, schemaInspector) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const result = {
         collections: {},
         relations: [],
@@ -95,6 +96,7 @@ async function getDatabaseSchema(database, schemaInspector) {
                     scale: column.numeric_scale || null,
                     special: [],
                     note: null,
+                    validation: null,
                     alias: false,
                 };
             }),
@@ -102,7 +104,7 @@ async function getDatabaseSchema(database, schemaInspector) {
     }
     const fields = [
         ...(await database
-            .select('id', 'collection', 'field', 'special', 'note')
+            .select('id', 'collection', 'field', 'special', 'note', 'validation')
             .from('directus_fields')),
         ...fields_1.systemFieldRows,
     ].filter((field) => (field.special ? (0, utils_1.toArray)(field.special) : []).includes('no-data') === false);
@@ -112,19 +114,25 @@ async function getDatabaseSchema(database, schemaInspector) {
         const existing = result.collections[field.collection].fields[field.field];
         const column = schemaOverview[field.collection].columns[field.field];
         const special = field.special ? (0, utils_1.toArray)(field.special) : [];
+        if (constants_1.ALIAS_TYPES.some((type) => special.includes(type)) === false && !existing)
+            continue;
         const type = (existing && (0, get_local_type_1.default)(column, { special })) || 'alias';
+        let validation = (_a = field.validation) !== null && _a !== void 0 ? _a : null;
+        if (validation && typeof validation === 'string')
+            validation = JSON.parse(validation);
         result.collections[field.collection].fields[field.field] = {
             field: field.field,
-            defaultValue: (_a = existing === null || existing === void 0 ? void 0 : existing.defaultValue) !== null && _a !== void 0 ? _a : null,
-            nullable: (_b = existing === null || existing === void 0 ? void 0 : existing.nullable) !== null && _b !== void 0 ? _b : true,
-            generated: (_c = existing === null || existing === void 0 ? void 0 : existing.generated) !== null && _c !== void 0 ? _c : false,
+            defaultValue: (_b = existing === null || existing === void 0 ? void 0 : existing.defaultValue) !== null && _b !== void 0 ? _b : null,
+            nullable: (_c = existing === null || existing === void 0 ? void 0 : existing.nullable) !== null && _c !== void 0 ? _c : true,
+            generated: (_d = existing === null || existing === void 0 ? void 0 : existing.generated) !== null && _d !== void 0 ? _d : false,
             type: type,
             dbType: (existing === null || existing === void 0 ? void 0 : existing.dbType) || null,
             precision: (existing === null || existing === void 0 ? void 0 : existing.precision) || null,
             scale: (existing === null || existing === void 0 ? void 0 : existing.scale) || null,
             special: special,
             note: field.note,
-            alias: (_d = existing === null || existing === void 0 ? void 0 : existing.alias) !== null && _d !== void 0 ? _d : true,
+            alias: (_e = existing === null || existing === void 0 ? void 0 : existing.alias) !== null && _e !== void 0 ? _e : true,
+            validation: (_f = validation) !== null && _f !== void 0 ? _f : null,
         };
     }
     const relationsService = new services_1.RelationsService({ knex: database, schema: result });

package/dist/utils/jwt.js

@@ -31,7 +31,7 @@ function verifyAccessJWT(token, secret) {
     }
     catch (err) {
         if (err instanceof jsonwebtoken_1.TokenExpiredError) {
-            throw new exceptions_1.InvalidTokenException('Token expired.');
+            throw new exceptions_1.TokenExpiredException();
         }
         else if (err instanceof jsonwebtoken_1.JsonWebTokenError) {
             throw new exceptions_1.InvalidTokenException('Token invalid.');

package/dist/utils/reduce-schema.js

@@ -10,7 +10,7 @@ const lodash_1 = require("lodash");
  * @returns Reduced schema
  */
 function reduceSchema(schema, permissions, actions = ['create', 'read', 'update', 'delete']) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const reduced = {
         collections: {},
         relations: [],
@@ -25,19 +25,27 @@ function reduceSchema(schema, permissions, actions = ['create', 'read', 'update'
         return acc;
     }, {})) !== null && _a !== void 0 ? _a : {};
     for (const [collectionName, collection] of Object.entries(schema.collections)) {
-        if (permissions === null || permissions === void 0 ? void 0 : permissions.some((permission) => permission.collection === collectionName && actions.includes(permission.action))) {
-            const fields = {};
-            for (const [fieldName, field] of Object.entries(schema.collections[collectionName].fields)) {
-                if (((_b = allowedFieldsInCollection[collectionName]) === null || _b === void 0 ? void 0 : _b.includes('*')) ||
-                    ((_c = allowedFieldsInCollection[collectionName]) === null || _c === void 0 ? void 0 : _c.includes(fieldName))) {
-                    fields[fieldName] = field;
-                }
+        if (!(permissions === null || permissions === void 0 ? void 0 : permissions.some((permission) => permission.collection === collectionName && actions.includes(permission.action)))) {
+            continue;
+        }
+        const fields = {};
+        for (const [fieldName, field] of Object.entries(schema.collections[collectionName].fields)) {
+            if (!((_b = allowedFieldsInCollection[collectionName]) === null || _b === void 0 ? void 0 : _b.includes('*')) &&
+                !((_c = allowedFieldsInCollection[collectionName]) === null || _c === void 0 ? void 0 : _c.includes(fieldName))) {
+                continue;
+            }
+            const relatedCollection = ((_d = schema.relations.find((relation) => relation.collection === collectionName && relation.field === fieldName)) === null || _d === void 0 ? void 0 : _d.related_collection) ||
+                ((_e = schema.relations.find((relation) => { var _a; return relation.related_collection === collectionName && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === fieldName; })) === null || _e === void 0 ? void 0 : _e.collection);
+            if (relatedCollection &&
+                !(permissions === null || permissions === void 0 ? void 0 : permissions.some((permission) => permission.collection === relatedCollection && actions.includes(permission.action)))) {
+                continue;
             }
-            reduced.collections[collectionName] = {
-                ...collection,
-                fields,
-            };
+            fields[fieldName] = field;
         }
+        reduced.collections[collectionName] = {
+            ...collection,
+            fields,
+        };
     }
     reduced.relations = schema.relations.filter((relation) => {
         var _a, _b, _c;

package/dist/utils/track.js

@@ -12,6 +12,7 @@ const os_1 = __importDefault(require("os"));
 const package_json_1 = require("../../package.json");
 const env_1 = __importDefault(require("../env"));
 const logger_1 = __importDefault(require("../logger"));
+const utils_1 = require("@directus/shared/utils");
 async function track(event) {
     if (env_1.default.TELEMETRY !== false) {
         const info = await getEnvInfo(event);
@@ -60,7 +61,7 @@ async function getEnvInfo(event) {
             transport: env_1.default.EMAIL_TRANSPORT,
         },
         auth: {
-            providers: env_1.default.AUTH_PROVIDERS.split(',')
+            providers: (0, utils_1.toArray)(env_1.default.AUTH_PROVIDERS)
                 .map((v) => v.trim())
                 .filter((v) => v),
         },
@@ -69,7 +70,7 @@ async function getEnvInfo(event) {
 }
 function getStorageDrivers() {
     const drivers = [];
-    const locations = env_1.default.STORAGE_LOCATIONS.split(',')
+    const locations = (0, utils_1.toArray)(env_1.default.STORAGE_LOCATIONS)
         .map((v) => v.trim())
         .filter((v) => v);
     for (const location of locations) {

package/dist/utils/url.d.ts

@@ -9,7 +9,7 @@ export declare class Url {
     isAbsolute(): boolean;
     isProtocolRelative(): boolean;
     isRootRelative(): boolean;
-    addPath(...paths: string[]): Url;
+    addPath(...paths: (string | number)[]): Url;
     setQuery(key: string, value: string): Url;
     toString({ rootRelative }?: {
         rootRelative: boolean;

package/dist/utils/url.js

@@ -28,7 +28,7 @@ class Url {
         return this.protocol === null && this.host === null;
     }
     addPath(...paths) {
-        const pathToAdd = paths.flatMap((p) => p.split('/')).filter((p) => p !== '');
+        const pathToAdd = paths.flatMap((p) => String(p).split('/')).filter((p) => p !== '');
         for (const pathSegment of pathToAdd) {
             if (pathSegment === '..') {
                 this.path.pop();

package/dist/utils/validate-query.js

@@ -47,21 +47,6 @@ function validateFilter(filter) {
         else if (key.startsWith('_')) {
             const value = nested;
             switch (key) {
-                case '_eq':
-                case '_neq':
-                case '_contains':
-                case '_ncontains':
-                case '_starts_with':
-                case '_nstarts_with':
-                case '_ends_with':
-                case '_nends_with':
-                case '_gt':
-                case '_gte':
-                case '_lt':
-                case '_lte':
-                default:
-                    validateFilterPrimitive(value, key);
-                    break;
                 case '_in':
                 case '_nin':
                 case '_between':
@@ -80,6 +65,25 @@ function validateFilter(filter) {
                 case '_nintersects_bbox':
                     validateGeometry(value, key);
                     break;
+                case '_none':
+                case '_some':
+                    validateFilter(nested);
+                    break;
+                case '_eq':
+                case '_neq':
+                case '_contains':
+                case '_ncontains':
+                case '_starts_with':
+                case '_nstarts_with':
+                case '_ends_with':
+                case '_nends_with':
+                case '_gt':
+                case '_gte':
+                case '_lt':
+                case '_lte':
+                default:
+                    validateFilterPrimitive(value, key);
+                    break;
             }
         }
         else if ((0, lodash_1.isPlainObject)(nested)) {

package/dist/utils/validate-storage.js

@@ -9,6 +9,7 @@ const logger_1 = __importDefault(require("../logger"));
 const fs_extra_1 = require("fs-extra");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
+const utils_1 = require("@directus/shared/utils");
 async function validateStorage() {
     if (env_1.default.DB_CLIENT === 'sqlite3') {
         try {
@@ -18,7 +19,8 @@ async function validateStorage() {
             logger_1.default.warn(`Directory for SQLite database file (${path_1.default.resolve(path_1.default.dirname(env_1.default.DB_FILENAME))}) is not read/writeable!`);
         }
     }
-    if (env_1.default.STORAGE_LOCATIONS.split(',').includes('local')) {
+    const usedStorageDrivers = (0, utils_1.toArray)(env_1.default.STORAGE_LOCATIONS).map((location) => env_1.default[`STORAGE_${location.toUpperCase()}_DRIVER`]);
+    if (usedStorageDrivers.includes('local')) {
         try {
             await (0, fs_extra_1.access)(env_1.default.STORAGE_LOCAL_ROOT, fs_1.constants.R_OK | fs_1.constants.W_OK);
         }

package/example.env

@@ -123,6 +123,10 @@ STORAGE_LOCAL_ROOT="./uploads"
 # STORAGE_GOOGLE_KEY_FILENAME="abcdef"
 # STORAGE_GOOGLE_BUCKET="my-files"
 
+
+## CSV of additional metadata keys
+# FILE_METADATA_ALLOW_LIST=
+
 ####################################################################################################
 # Security