directus 9.9.0 → 9.11.0

package/dist/utils/apply-query/operators/insensitive-not-contains.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nicontains',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue === null || compareValue === void 0 ? void 0 : compareValue.toLowerCase()}%`]);
+    },
+});

package/dist/utils/apply-query/operators/insensitive-not-ends-with.operator.d.ts

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

package/dist/utils/apply-query/operators/insensitive-not-ends-with.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_niends_with',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue === null || compareValue === void 0 ? void 0 : compareValue.toLowerCase()}`]);
+    },
+});

package/dist/utils/apply-query/operators/insensitive-not-equals.operator.d.ts

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

package/dist/utils/apply-query/operators/insensitive-not-equals.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nieq',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereRaw(`LOWER(??) != ?`, [selectionRaw, `${compareValue === null || compareValue === void 0 ? void 0 : compareValue.toLowerCase()}`]);
+    },
+});

package/dist/utils/apply-query/operators/insensitive-not-starts-with.operator.d.ts

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

package/dist/utils/apply-query/operators/insensitive-not-starts-with.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nistarts_with',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `${compareValue === null || compareValue === void 0 ? void 0 : compareValue.toLowerCase()}%`]);
+    },
+});

package/dist/utils/apply-query/operators/insensitive-starts-with.operator.d.ts

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

package/dist/utils/apply-query/operators/insensitive-starts-with.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_istarts_with',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `${compareValue === null || compareValue === void 0 ? void 0 : compareValue.toLowerCase()}%`]);
+    },
+});

package/dist/utils/apply-query/operators/intersects-bbox.operator.d.ts

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

package/dist/utils/apply-query/operators/intersects-bbox.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_intersects_bbox',
+    apply: ({ helpers, query, selectionRaw, compareValue }) => {
+        query.whereRaw(helpers.st.intersects_bbox(selectionRaw, compareValue));
+    },
+});

package/dist/utils/apply-query/operators/intersects.operator.d.ts

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

package/dist/utils/apply-query/operators/intersects.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_intersects',
+    apply: ({ helpers, query, selectionRaw, compareValue }) => {
+        query.whereRaw(helpers.st.intersects(selectionRaw, compareValue));
+    },
+});

package/dist/utils/apply-query/operators/is-empty.operator.d.ts

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

package/dist/utils/apply-query/operators/is-empty.operator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_empty',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        if (compareValue) {
+            query.where(selectionRaw, '=', '');
+        }
+        else {
+            query.where(selectionRaw, '!=', '');
+        }
+    },
+});

package/dist/utils/apply-query/operators/is-not-empty.operator.d.ts

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

package/dist/utils/apply-query/operators/is-not-empty.operator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nempty',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        if (compareValue) {
+            query.where(selectionRaw, '!=', '');
+        }
+        else {
+            query.where(selectionRaw, '=', '');
+        }
+    },
+});

package/dist/utils/apply-query/operators/is-not-null.operator.d.ts

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

package/dist/utils/apply-query/operators/is-not-null.operator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nnull',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        if (compareValue) {
+            query.whereNotNull(selectionRaw);
+        }
+        else {
+            query.whereNull(selectionRaw);
+        }
+    },
+});

package/dist/utils/apply-query/operators/is-null.operator.d.ts

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

package/dist/utils/apply-query/operators/is-null.operator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_null',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        if (compareValue) {
+            query.whereNull(selectionRaw);
+        }
+        else {
+            query.whereNotNull(selectionRaw);
+        }
+    },
+});

package/dist/utils/apply-query/operators/less-than-equals.operator.d.ts

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

package/dist/utils/apply-query/operators/less-than-equals.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_lte',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.where(selectionRaw, '<=', compareValue);
+    },
+});

package/dist/utils/apply-query/operators/less-than.operator.d.ts

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

package/dist/utils/apply-query/operators/less-than.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_lt',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.where(selectionRaw, '<', compareValue);
+    },
+});

package/dist/utils/apply-query/operators/not-between.operator.d.ts

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

package/dist/utils/apply-query/operators/not-between.operator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nbetween',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        let value = compareValue;
+        if (typeof value === 'string')
+            value = value.split(',');
+        if (!(value instanceof Array))
+            throw new Error('Invalid value for between operator');
+        if (value.length !== 2)
+            throw new Error('Expected two values for between operator');
+        query.whereNotBetween(selectionRaw, value);
+    },
+});

package/dist/utils/apply-query/operators/not-contains.operator.d.ts

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

package/dist/utils/apply-query/operators/not-contains.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_ncontains',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereNot(selectionRaw, 'like', `%${compareValue}%`);
+    },
+});

package/dist/utils/apply-query/operators/not-ends-with.operator.d.ts

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

package/dist/utils/apply-query/operators/not-ends-with.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nends_with',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereNot(selectionRaw, 'like', `%${compareValue}`);
+    },
+});

package/dist/utils/apply-query/operators/not-equals.operator.d.ts

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

package/dist/utils/apply-query/operators/not-equals.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_neq',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereNot(selectionRaw, compareValue);
+    },
+});

package/dist/utils/apply-query/operators/not-in.operator.d.ts

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

package/dist/utils/apply-query/operators/not-in.operator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nin',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        let value = compareValue;
+        if (typeof value === 'string')
+            value = value.split(',');
+        if (!(value instanceof Array))
+            throw new Error('Invalid value for in operator');
+        query.whereNotIn(selectionRaw, value);
+    },
+});

package/dist/utils/apply-query/operators/not-intersects-bbox.operator.d.ts

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

package/dist/utils/apply-query/operators/not-intersects-bbox.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nintersects_bbox',
+    apply: ({ helpers, query, selectionRaw, compareValue }) => {
+        query.whereRaw(helpers.st.nintersects_bbox(selectionRaw, compareValue));
+    },
+});

package/dist/utils/apply-query/operators/not-intersects.operator.d.ts

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

package/dist/utils/apply-query/operators/not-intersects.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nintersects',
+    apply: ({ helpers, query, selectionRaw, compareValue }) => {
+        query.whereRaw(helpers.st.nintersects(selectionRaw, compareValue));
+    },
+});

package/dist/utils/apply-query/operators/not-starts-with.operator.d.ts

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

package/dist/utils/apply-query/operators/not-starts-with.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_nstarts_with',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereNot(selectionRaw, 'like', `${compareValue}%`);
+    },
+});

package/dist/utils/apply-query/operators/operator-register.d.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+import { Helpers } from '../../../database/helpers';
+export declare type OperatorRegisterContext = {
+    query: Knex.QueryBuilder<any, any>;
+    selectionRaw: any;
+    compareValue: any;
+    helpers: Helpers;
+};
+export declare type OperatorRegister = {
+    operator: string;
+    apply: (context: OperatorRegisterContext) => void;
+};
+export declare function registerOperator(register: OperatorRegister): OperatorRegister;

package/dist/utils/apply-query/operators/operator-register.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOperator = void 0;
+function registerOperator(register) {
+    return register;
+}
+exports.registerOperator = registerOperator;

package/dist/utils/apply-query/operators/starts-with.operator.d.ts

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

package/dist/utils/apply-query/operators/starts-with.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_starts_with',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.where(selectionRaw, 'like', `${compareValue}%`);
+    },
+});

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

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

package/dist/utils/apply-snapshot.js

@@ -4,13 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 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"));
-const get_schema_1 = require("./get-schema");
-const services_1 = require("../services");
 const lodash_1 = require("lodash");
+const database_1 = __importDefault(require("../database"));
 const logger_1 = __importDefault(require("../logger"));
+const services_1 = require("../services");
+const get_schema_1 = require("./get-schema");
+const get_snapshot_1 = require("./get-snapshot");
+const get_snapshot_diff_1 = require("./get-snapshot-diff");
 async function applySnapshot(snapshot, options) {
     var _a, _b, _c, _d;
     const database = (_a = options === null || options === void 0 ? void 0 : options.database) !== null && _a !== void 0 ? _a : (0, database_1.default)();
@@ -19,55 +19,70 @@ async function applySnapshot(snapshot, options) {
     const snapshotDiff = (_d = options === null || options === void 0 ? void 0 : options.diff) !== null && _d !== void 0 ? _d : (0, get_snapshot_diff_1.getSnapshotDiff)(current, snapshot);
     await database.transaction(async (trx) => {
         const collectionsService = new services_1.CollectionsService({ knex: trx, schema });
-        for (const { collection, diff } of snapshotDiff.collections) {
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
-                try {
-                    await collectionsService.deleteOne(collection);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to delete collection "${collection}"`);
-                    throw err;
+        const getNestedCollectionsToCreate = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => { var _a, _b; return ((_b = (_a = diff[0].rhs) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.group) === currentLevelCollection; });
+        const getNestedCollectionsToDelete = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => { var _a, _b; return ((_b = (_a = diff[0].lhs) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.group) === currentLevelCollection; });
+        const createCollections = async (collections) => {
+            for (const { collection, diff } of collections) {
+                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N' && diff[0].rhs) {
+                    // We'll nest the to-be-created fields in the same collection creation, to prevent
+                    // creating a collection without a primary key
+                    const fields = snapshotDiff.fields
+                        .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;
+                        }
+                        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,
+                            fields,
+                        });
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to create collection "${collection}"`);
+                        throw err;
+                    }
+                    // Now that the fields are in for this collection, we can strip them from the field edits
+                    snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
+                    await createCollections(getNestedCollectionsToCreate(collection));
                 }
             }
-            if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N' && diff[0].rhs) {
-                // We'll nest the to-be-created fields in the same collection creation, to prevent
-                // creating a collection without a primary key
-                const fields = snapshotDiff.fields
-                    .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;
+        };
+        const deleteCollections = async (collections) => {
+            for (const { collection, diff } of collections) {
+                if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
+                    await deleteCollections(getNestedCollectionsToDelete(collection));
+                    try {
+                        await collectionsService.deleteOne(collection);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to delete collection "${collection}"`);
+                        throw err;
                     }
-                    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,
-                        fields,
-                    });
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to create collection "${collection}"`);
-                    throw err;
                 }
-                // Now that the fields are in for this collection, we can strip them from the field
-                // edits
-                snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
             }
+        };
+        // 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; }));
+        // 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) {
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A') {
                 const newValues = snapshot.collections.find((field) => {
                     return field.collection === collection;

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

@@ -75,9 +75,11 @@ 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];
+                }
             }
             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
@@ -85,7 +87,7 @@ async function getASTFromQuery(collection, query, schema, options) {
                 !!schema.relations.find((relation) => { var _a; return relation.related_collection === parentCollection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === name; });
             if (isRelational) {
                 // field is relational
-                const parts = name.split('.');
+                const parts = fieldKey.split('.');
                 let rootField = parts[0];
                 let collectionScope = null;
                 // a2o related collection scoped field selector `fields=sections.section_id:headings.title`
@@ -162,6 +164,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-path.d.ts

@@ -0,0 +1,16 @@
+import { Relation } from '@directus/shared/types';
+declare type AliasMap = string | {
+    [key: string]: AliasMap;
+};
+export declare type ColPathProps = {
+    path: string[];
+    collection: string;
+    aliasMap: AliasMap;
+    relations: Relation[];
+};
+/**
+ * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
+ * For example: ['author', 'role', 'name'] -> 'ljnsv.name'
+ */
+export declare function getColumnPath({ path, collection, aliasMap, relations }: ColPathProps): string | void;
+export {};