directus 9.13.0 → 9.14.2

package/dist/operations/item-read/index.js

@@ -6,7 +6,7 @@ const get_accountability_for_role_1 = require("../../utils/get-accountability-fo
 const sanitize_query_1 = require("../../utils/sanitize-query");
 exports.default = (0, utils_1.defineOperationApi)({
     id: 'item-read',
-    handler: async ({ collection, key, query, permissions }, { accountability, database, getSchema }) => {
+    handler: async ({ collection, key, query, emitEvents, permissions }, { accountability, database, getSchema }) => {
         const schema = await getSchema({ database });
         let customAccountability;
         if (!permissions || permissions === '$trigger') {
@@ -35,10 +35,10 @@ exports.default = (0, utils_1.defineOperationApi)({
         else {
             const keys = (0, utils_1.toArray)(key);
             if (keys.length === 1) {
-                result = await itemsService.readOne(keys[0], sanitizedQueryObject);
+                result = await itemsService.readOne(keys[0], sanitizedQueryObject, { emitEvents });
             }
             else {
-                result = await itemsService.readMany(keys, sanitizedQueryObject);
+                result = await itemsService.readMany(keys, sanitizedQueryObject, { emitEvents });
             }
         }
         return result;

package/dist/operations/request/index.js

@@ -12,7 +12,7 @@ exports.default = (0, utils_1.defineOperationApi)({
             acc[header] = value;
             return acc;
         }, {});
-        const result = await (0, axios_1.default)({ url, method, data: body, headers: customHeaders });
+        const result = await (0, axios_1.default)({ url: encodeURI(url), method, data: body, headers: customHeaders });
         return { status: result.status, statusText: result.statusText, headers: result.headers, data: result.data };
     },
 });

package/dist/services/authorization.js

@@ -48,7 +48,7 @@ class AuthorizationService {
                 collections.push(...ast.names.map((name) => ({ collection: name, field: ast.fieldKey })));
                 for (const children of Object.values(ast.children)) {
                     for (const nestedNode of children) {
-                        if (nestedNode.type !== 'field') {
+                        if (nestedNode.type !== 'field' && nestedNode.type !== 'functionField') {
                             collections.push(...getCollectionsFromAST(nestedNode));
                         }
                     }
@@ -60,7 +60,13 @@ class AuthorizationService {
                     field: ast.type === 'root' ? null : ast.fieldKey,
                 });
                 for (const nestedNode of ast.children) {
-                    if (nestedNode.type !== 'field') {
+                    if (nestedNode.type === 'functionField') {
+                        collections.push({
+                            collection: nestedNode.relatedCollection,
+                            field: null,
+                        });
+                    }
+                    else if (nestedNode.type !== 'field') {
                         collections.push(...getCollectionsFromAST(nestedNode));
                     }
                 }
@@ -69,7 +75,7 @@ class AuthorizationService {
         }
         function validateFields(ast) {
             var _a, _b, _c;
-            if (ast.type !== 'field') {
+            if (ast.type !== 'field' && ast.type !== 'functionField') {
                 if (ast.type === 'a2o') {
                     for (const [collection, children] of Object.entries(ast.children)) {
                         checkFields(collection, children, (_b = (_a = ast.query) === null || _a === void 0 ? void 0 : _a[collection]) === null || _b === void 0 ? void 0 : _b.aggregate);
@@ -112,7 +118,7 @@ class AuthorizationService {
         function validateFilterPermissions(ast, schema, action, accountability) {
             var _a, _b, _c, _d, _e;
             let requiredFieldPermissions = {};
-            if (ast.type !== 'field') {
+            if (ast.type !== 'field' && ast.type !== 'functionField') {
                 if (ast.type === 'a2o') {
                     for (const collection of Object.keys(ast.children)) {
                         requiredFieldPermissions = mergeRequiredFieldPermissions(requiredFieldPermissions, extractRequiredFieldPermissions(collection, (_c = (_b = (_a = ast.query) === null || _a === void 0 ? void 0 : _a[collection]) === null || _b === void 0 ? void 0 : _b.filter) !== null && _c !== void 0 ? _c : {}));
@@ -290,7 +296,11 @@ class AuthorizationService {
             }
         }
         function applyFilters(ast, accountability) {
-            if (ast.type !== 'field') {
+            if (ast.type === 'functionField') {
+                const collection = ast.relatedCollection;
+                updateFilterQuery(collection, ast.query);
+            }
+            else if (ast.type !== 'field') {
                 if (ast.type === 'a2o') {
                     const collections = Object.keys(ast.children);
                     for (const collection of collections) {

package/dist/services/fields.js

@@ -351,6 +351,7 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
+        const runPostColumnDelete = await this.helpers.schema.preColumnDelete();
         try {
             await emitter_1.default.emitFilter('fields.delete', [field], {
                 collection: collection,
@@ -439,6 +440,9 @@ class FieldsService {
             });
         }
         finally {
+            if (runPostColumnDelete) {
+                await this.helpers.schema.postColumnDelete();
+            }
             if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
                 await this.cache.clear();
             }

package/dist/services/graphql/index.js

@@ -12,6 +12,7 @@ const lodash_1 = require("lodash");
 const ms_1 = __importDefault(require("ms"));
 const cache_1 = require("../../cache");
 const constants_1 = require("../../constants");
+const constants_2 = require("@directus/shared/constants");
 const database_1 = __importDefault(require("../../database"));
 const env_1 = __importDefault(require("../../env"));
 const exceptions_1 = require("../../exceptions");
@@ -488,6 +489,12 @@ class GraphQLService {
                     _nnull: {
                         type: graphql_1.GraphQLBoolean,
                     },
+                    _between: {
+                        type: new graphql_1.GraphQLList(string_or_float_1.GraphQLStringOrFloat),
+                    },
+                    _nbetween: {
+                        type: new graphql_1.GraphQLList(string_or_float_1.GraphQLStringOrFloat),
+                    },
                 },
             });
             // Uses StringOrFloat rather than Float to support api dynamic variables (like `$NOW`)
@@ -524,6 +531,12 @@ class GraphQLService {
                     _nnull: {
                         type: graphql_1.GraphQLBoolean,
                     },
+                    _between: {
+                        type: new graphql_1.GraphQLList(string_or_float_1.GraphQLStringOrFloat),
+                    },
+                    _nbetween: {
+                        type: new graphql_1.GraphQLList(string_or_float_1.GraphQLStringOrFloat),
+                    },
                 },
             });
             const GeometryFilterOperators = schemaComposer.createInputTC({
@@ -671,6 +684,16 @@ class GraphQLService {
                         return acc;
                     }, {}),
                 });
+                const countType = 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;
+                    }, {}),
+                });
                 AggregateMethods[collection.collection] = {
                     group: {
                         name: 'group',
@@ -682,16 +705,11 @@ class GraphQLService {
                     },
                     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;
-                            }, {}),
-                        }),
+                        type: countType,
+                    },
+                    countDistinct: {
+                        name: 'countDistinct',
+                        type: countType,
                     },
                 };
                 const hasNumericAggregates = Object.values(collection.fields).some((field) => {
@@ -711,10 +729,6 @@ class GraphQLService {
                             name: 'sum',
                             type: AggregatedFields[collection.collection],
                         },
-                        countDistinct: {
-                            name: 'countDistinct',
-                            type: AggregatedFields[collection.collection],
-                        },
                         avgDistinct: {
                             name: 'avgDistinct',
                             type: AggregatedFields[collection.collection],
@@ -1042,6 +1056,17 @@ class GraphQLService {
             };
             query.limit = 1;
         }
+        // Transform count(a.b.c) into a.b.count(c)
+        for (let fieldIndex = 0; fieldIndex < query.fields.length; fieldIndex++) {
+            if (query.fields[fieldIndex].includes('(') && query.fields[fieldIndex].includes(')')) {
+                const functionName = query.fields[fieldIndex].split('(')[0];
+                const columnNames = query.fields[fieldIndex].match(constants_2.REGEX_BETWEEN_PARENS)[1].split('.');
+                if (columnNames.length > 1) {
+                    const column = columnNames.pop();
+                    query.fields[fieldIndex] = columnNames.join('.') + '.' + functionName + '(' + column + ')';
+                }
+            }
+        }
         const result = await this.read(collection, query);
         if (args.id) {
             return (result === null || result === void 0 ? void 0 : result[0]) || null;
@@ -1288,7 +1313,7 @@ class GraphQLService {
                         result[currentKey] = Object.values(value)[0];
                     }
                     else {
-                        result[currentKey] = (0, lodash_1.isObject)(value) ? replaceFuncDeep(value) : value;
+                        result[currentKey] = (value === null || value === void 0 ? void 0 : value.constructor) === Object ? replaceFuncDeep(value) : value;
                     }
                 });
             }

package/dist/services/import-export.js

@@ -102,7 +102,12 @@ class ImportService {
                         else {
                             try {
                                 const parsedJson = (0, utils_1.parseJSON)(value);
-                                (0, lodash_1.set)(result, key, parsedJson);
+                                if (typeof parsedJson === 'number') {
+                                    (0, lodash_1.set)(result, key, value);
+                                }
+                                else {
+                                    (0, lodash_1.set)(result, key, parsedJson);
+                                }
                             }
                             catch {
                                 (0, lodash_1.set)(result, key, value);

package/dist/services/items.d.ts

@@ -5,6 +5,7 @@ import { AbstractService, AbstractServiceOptions, Item as AnyItem, MutationOptio
 export declare type QueryOptions = {
     stripNonRequested?: boolean;
     permissionsAction?: PermissionsAction;
+    emitEvents?: boolean;
 };
 export declare class ItemsService<Item extends AnyItem = AnyItem> implements AbstractService {
     collection: string;

package/dist/services/items.js

@@ -221,23 +221,27 @@ class ItemsService {
         if (records === null) {
             throw new exceptions_1.ForbiddenException();
         }
-        const filteredRecords = await emitter_1.default.emitFilter(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, records, {
-            query,
-            collection: this.collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        emitter_1.default.emitAction(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, {
-            payload: filteredRecords,
-            query,
-            collection: this.collection,
-        }, {
-            database: this.knex || (0, database_1.default)(),
-            schema: this.schema,
-            accountability: this.accountability,
-        });
+        const filteredRecords = (opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false
+            ? await emitter_1.default.emitFilter(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, records, {
+                query,
+                collection: this.collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            })
+            : records;
+        if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false) {
+            emitter_1.default.emitAction(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, {
+                payload: filteredRecords,
+                query,
+                collection: this.collection,
+            }, {
+                database: this.knex || (0, database_1.default)(),
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        }
         return filteredRecords;
     }
     /**

package/dist/services/notifications.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationsService = void 0;
 const items_1 = require("./items");
 const md_1 = require("../utils/md");
 const users_1 = require("./users");
 const mail_1 = require("./mail");
+const logger_1 = __importDefault(require("../logger"));
 class NotificationsService extends items_1.ItemsService {
     constructor(options) {
         super('directus_notifications', options);
@@ -12,29 +16,36 @@ class NotificationsService extends items_1.ItemsService {
         this.mailService = new mail_1.MailService({ schema: this.schema, accountability: this.accountability });
     }
     async createOne(data, opts) {
+        const response = await super.createOne(data, opts);
         await this.sendEmail(data);
-        return super.createOne(data, opts);
+        return response;
     }
     async createMany(data, opts) {
+        const response = await super.createMany(data, opts);
         for (const notification of data) {
             await this.sendEmail(notification);
         }
-        return super.createMany(data, opts);
+        return response;
     }
     async sendEmail(data) {
         if (data.recipient) {
             const user = await this.usersService.readOne(data.recipient, { fields: ['email', 'email_notifications'] });
             if (user.email && user.email_notifications === true) {
-                await this.mailService.send({
-                    template: {
-                        name: 'base',
-                        data: {
-                            html: data.message ? (0, md_1.md)(data.message) : '',
+                try {
+                    await this.mailService.send({
+                        template: {
+                            name: 'base',
+                            data: {
+                                html: data.message ? (0, md_1.md)(data.message) : '',
+                            },
                         },
-                    },
-                    to: user.email,
-                    subject: data.subject,
-                });
+                        to: user.email,
+                        subject: data.subject,
+                    });
+                }
+                catch (error) {
+                    logger_1.default.error(error.message);
+                }
             }
         }
     }

package/dist/services/payload.js

@@ -4,8 +4,8 @@ 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 utils_1 = require("@directus/shared/utils");
 const flat_1 = require("flat");
 const joi_1 = __importDefault(require("joi"));
 const lodash_1 = require("lodash");
@@ -259,15 +259,18 @@ class PayloadService {
                 else {
                     if (value instanceof Date === false && typeof value === 'string') {
                         if (dateColumn.type === 'date') {
-                            const [date] = value.split('T');
-                            const [year, month, day] = date.split('-');
-                            payload[name] = new Date(Number(year), Number(month) - 1, Number(day));
+                            const parsedDate = (0, date_fns_1.parseISO)(value);
+                            if (!(0, date_fns_1.isValid)(parsedDate)) {
+                                throw new exceptions_1.InvalidPayloadException(`Invalid Date format in field "${dateColumn.field}"`);
+                            }
+                            payload[name] = parsedDate;
                         }
                         if (dateColumn.type === 'dateTime') {
-                            const [date, time] = value.split('T');
-                            const [year, month, day] = date.split('-');
-                            const [hours, minutes, seconds] = time.substring(0, 8).split(':');
-                            payload[name] = new Date(Number(year), Number(month) - 1, Number(day), Number(hours), Number(minutes), Number(seconds));
+                            const parsedDate = (0, date_fns_1.parseISO)(value);
+                            if (!(0, date_fns_1.isValid)(parsedDate)) {
+                                throw new exceptions_1.InvalidPayloadException(`Invalid DateTime format in field "${dateColumn.field}"`);
+                            }
+                            payload[name] = parsedDate;
                         }
                         if (dateColumn.type === 'timestamp') {
                             const newValue = this.helpers.date.writeTimestamp(value);

package/dist/services/server.js

@@ -51,7 +51,7 @@ class ServerService {
         this.settingsService = new settings_1.SettingsService({ knex: this.knex, schema: this.schema });
     }
     async serverInfo() {
-        var _a;
+        var _a, _b;
         const info = {};
         const projectInfo = await this.settingsService.readSingleton({
             fields: [
@@ -67,7 +67,18 @@ class ServerService {
             ],
         });
         info.project = projectInfo;
-        if (((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) === true) {
+        if ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.user) {
+            if (env_1.default.RATE_LIMITER_ENABLED) {
+                info.rateLimit = {
+                    points: env_1.default.RATE_LIMITER_POINTS,
+                    duration: env_1.default.RATE_LIMITER_DURATION,
+                };
+            }
+            else {
+                info.rateLimit = false;
+            }
+        }
+        if (((_b = this.accountability) === null || _b === void 0 ? void 0 : _b.admin) === true) {
             const osType = os_1.default.type() === 'Darwin' ? 'macOS' : os_1.default.type();
             const osVersion = osType === 'macOS' ? `${(0, macos_release_1.default)().name} (${(0, macos_release_1.default)().version})` : os_1.default.release();
             info.directus = {

package/dist/types/ast.d.ts

@@ -2,7 +2,7 @@ import { Query, Relation } from '@directus/shared/types';
 export declare type M2ONode = {
     type: 'm2o';
     name: string;
-    children: (NestedCollectionNode | FieldNode)[];
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
     query: Query;
     fieldKey: string;
     relation: Relation;
@@ -13,7 +13,7 @@ export declare type A2MNode = {
     type: 'a2o';
     names: string[];
     children: {
-        [collection: string]: (NestedCollectionNode | FieldNode)[];
+        [collection: string]: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
     };
     query: {
         [collection: string]: Query;
@@ -28,7 +28,7 @@ export declare type A2MNode = {
 export declare type O2MNode = {
     type: 'o2m';
     name: string;
-    children: (NestedCollectionNode | FieldNode)[];
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
     query: Query;
     fieldKey: string;
     relation: Relation;
@@ -41,9 +41,16 @@ export declare type FieldNode = {
     name: string;
     fieldKey: string;
 };
+export declare type FunctionFieldNode = {
+    type: 'functionField';
+    name: string;
+    fieldKey: string;
+    query: Query;
+    relatedCollection: string;
+};
 export declare type AST = {
     type: 'root';
     name: string;
-    children: (NestedCollectionNode | FieldNode)[];
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
     query: Query;
 };

package/dist/utils/apply-query.js

@@ -129,8 +129,8 @@ function applySort(knex, schema, rootQuery, rootSort, collection, subQuery = fal
                 relations,
                 knex,
             });
-            const colPath = (0, get_column_path_1.getColumnPath)({ path: column, collection, aliasMap, relations }) || '';
-            const [alias, field] = colPath.split('.');
+            const { columnPath } = (0, get_column_path_1.getColumnPath)({ path: column, collection, aliasMap, relations });
+            const [alias, field] = columnPath.split('.');
             return {
                 order,
                 column: (0, get_column_1.getColumn)(knex, alias, field, false, schema),
@@ -208,18 +208,10 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             const { operator: filterOperator, value: filterValue } = getOperation(key, value);
             if (relationType === 'm2o' || relationType === 'a2o' || relationType === null) {
                 if (filterPath.length > 1) {
-                    const columnName = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
-                    if (!columnName)
+                    const { columnPath, targetCollection } = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
+                    if (!columnPath)
                         continue;
-                    if (relation === null || relation === void 0 ? void 0 : relation.related_collection) {
-                        applyFilterToQuery(columnName, filterOperator, filterValue, logical, relation.related_collection); // m2o
-                    }
-                    else if (filterPath[0].includes(':')) {
-                        applyFilterToQuery(columnName, filterOperator, filterValue, logical, filterPath[0].split(':')[1]); // a2o
-                    }
-                    else {
-                        applyFilterToQuery(columnName, filterOperator, filterValue, logical);
-                    }
+                    applyFilterToQuery(columnPath, filterOperator, filterValue, logical, targetCollection);
                 }
                 else {
                     applyFilterToQuery(`${collection}.${filterPath[0]}`, filterOperator, filterValue, logical);

package/dist/utils/apply-snapshot.js

@@ -32,23 +32,18 @@ async function applySnapshot(snapshot, options) {
                         .filter((fieldDiff) => fieldDiff.collection === collection)
                         .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;
+                        var _a, _b, _c, _d, _e;
+                        // Casts field type to UUID when applying non-PostgreSQL schema onto PostgreSQL database.
+                        // This is needed because they snapshots UUID fields as char with length 36.
+                        if (((_a = fieldDiff.schema) === null || _a === void 0 ? void 0 : _a.data_type) === 'char' &&
+                            ((_b = fieldDiff.schema) === null || _b === void 0 ? void 0 : _b.max_length) === 36 &&
+                            (((_c = fieldDiff.schema) === null || _c === void 0 ? void 0 : _c.is_primary_key) ||
+                                (((_d = fieldDiff.schema) === null || _d === void 0 ? void 0 : _d.foreign_key_table) && ((_e = fieldDiff.schema) === null || _e === void 0 ? void 0 : _e.foreign_key_column)))) {
+                            return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
                         }
-                        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')
+                        else {
                             return fieldDiff;
-                        return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
+                        }
                     });
                     try {
                         await collectionsService.createOne({
@@ -80,8 +75,37 @@ async function applySnapshot(snapshot, options) {
                 }
             }
         };
-        // create top level collections (no group) first, then continue with nested collections recursively
-        await createCollections(snapshotDiff.collections.filter(({ diff }) => { var _a; return diff[0].kind === 'N' && ((_a = diff[0].rhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
+        // Finds all collections that need to be created
+        const filterCollectionsForCreation = ({ diff }) => {
+            var _a;
+            // Check new collections only
+            const isNewCollection = diff[0].kind === 'N';
+            if (!isNewCollection)
+                return false;
+            // Create now if no group
+            const groupName = (_a = diff[0].rhs.meta) === null || _a === void 0 ? void 0 : _a.group;
+            if (!groupName)
+                return true;
+            // Check if parent collection already exists in schema
+            const parentExists = current.collections.find((c) => c.collection === groupName) !== undefined;
+            // If this is a new collection and the parent collection doesn't exist in current schema ->
+            // Check if the parent collection will be created as part of applying this snapshot ->
+            // If yes -> this collection will be created recursively
+            // If not -> create now
+            // (ex.)
+            // TopLevelCollection - I exist in current schema
+            // 		NestedCollection - I exist in snapshotDiff as a new collection
+            //			TheCurrentCollectionInIteration - I exist in snapshotDiff as a new collection but will be created as part of NestedCollection
+            const parentWillBeCreatedInThisApply = snapshotDiff.collections.filter(({ collection, diff }) => diff[0].kind === 'N' && collection === groupName)
+                .length > 0;
+            // Has group, but parent is not new, parent is also not being created in this snapshot apply
+            if (parentExists && !parentWillBeCreatedInThisApply)
+                return true;
+            return false;
+        };
+        // Create top level collections (no group, or highest level in existing group) first,
+        // then continue with nested collections recursively
+        await createCollections(snapshotDiff.collections.filter(filterCollectionsForCreation));
         // delete top level collections (no group) first, then continue with nested collections recursively
         await deleteCollections(snapshotDiff.collections.filter(({ diff }) => { var _a; return diff[0].kind === 'D' && ((_a = diff[0].lhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
         for (const { collection, diff } of snapshotDiff.collections) {

package/dist/utils/filter-items.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterItems = void 0;
-const generate_joi_1 = __importDefault(require("./generate-joi"));
+const utils_1 = require("@directus/shared/utils");
 /*
  Note: Filtering is normally done through SQL in run-ast. This function can be used in case an already
  existing array of items has to be filtered using the same filter syntax as used in the ast-to-sql flow
@@ -16,7 +13,7 @@ function filterItems(items, filter) {
         return passesFilter(item, filter);
     });
     function passesFilter(item, filter) {
-        if (!filter)
+        if (!filter || Object.keys(filter).length === 0)
             return true;
         if (Object.keys(filter)[0] === '_and') {
             const subfilter = Object.values(filter)[0];
@@ -31,7 +28,7 @@ function filterItems(items, filter) {
             });
         }
         else {
-            const schema = (0, generate_joi_1.default)(filter);
+            const schema = (0, utils_1.generateJoi)(filter);
             const { error } = schema.validate(item);
             return error === undefined;
         }

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

@@ -5,6 +5,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const lodash_1 = require("lodash");
 const get_relation_type_1 = require("../utils/get-relation-type");
+const constants_1 = require("@directus/shared/constants");
 async function getASTFromQuery(collection, query, schema, options) {
     var _a, _b, _c, _d, _e;
     query = (0, lodash_1.cloneDeep)(query);
@@ -118,6 +119,23 @@ async function getASTFromQuery(collection, query, schema, options) {
                 }
             }
             else {
+                if (fieldKey.includes('(') && fieldKey.includes(')')) {
+                    const columnName = fieldKey.match(constants_1.REGEX_BETWEEN_PARENS)[1];
+                    const foundField = schema.collections[parentCollection].fields[columnName];
+                    if (foundField && foundField.type === 'alias') {
+                        const foundRelation = schema.relations.find((relation) => { var _a; return relation.related_collection === parentCollection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === columnName; });
+                        if (foundRelation) {
+                            children.push({
+                                type: 'functionField',
+                                name,
+                                fieldKey,
+                                query: {},
+                                relatedCollection: foundRelation.collection,
+                            });
+                            continue;
+                        }
+                    }
+                }
                 children.push({ type: 'field', name, fieldKey });
             }
         }