directus 9.8.0 → 9.10.0

package/dist/utils/apply-query.js

@@ -3,33 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyAggregate = exports.applySearch = exports.applyFilter = void 0;
+exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.applySort = void 0;
+const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
+const helpers_1 = require("../database/helpers");
 const exceptions_1 = require("../exceptions");
 const get_column_1 = require("./get-column");
-const get_relation_type_1 = require("./get-relation-type");
-const helpers_1 = require("../database/helpers");
-const utils_1 = require("@directus/shared/utils");
+const get_column_path_1 = require("./get-column-path");
+const get_relation_info_1 = require("./get-relation-info");
 const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
 /**
  * Apply the Query to a given Knex query builder instance
  */
 function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false) {
     if (query.sort) {
-        dbQuery.orderBy(query.sort.map((sortField) => {
-            let column = sortField;
-            let order = 'asc';
-            if (sortField.startsWith('-')) {
-                column = column.substring(1);
-                order = 'desc';
-            }
-            return {
-                order,
-                column: (0, get_column_1.getColumn)(knex, collection, column, false, schema),
-            };
-        }));
+        applySort(knex, schema, dbQuery, query.sort, collection, subQuery);
     }
     if (typeof query.limit === 'number' && query.limit !== -1) {
         dbQuery.limit(query.limit);
@@ -55,44 +45,109 @@ function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false)
     return dbQuery;
 }
 exports.default = applyQuery;
-function getRelationInfo(relations, collection, field) {
-    var _a, _b;
-    const implicitRelation = (_a = field.match(/^\$FOLLOW\((.*?),(.*?)(?:,(.*?))?\)$/)) === null || _a === void 0 ? void 0 : _a.slice(1);
-    if (implicitRelation) {
-        if (implicitRelation[2] === undefined) {
-            const [m2oCollection, m2oField] = implicitRelation;
-            const relation = {
-                collection: m2oCollection,
-                field: m2oField,
-                related_collection: collection,
-                schema: null,
-                meta: null,
-            };
-            return { relation, relationType: 'o2m' };
+function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, relations, knex }) {
+    path = (0, lodash_1.clone)(path);
+    followRelation(path);
+    function followRelation(pathParts, parentCollection = collection, parentAlias) {
+        /**
+         * For A2M fields, the path can contain an optional collection scope <field>:<scope>
+         */
+        const pathRoot = pathParts[0].split(':')[0];
+        const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, parentCollection, pathRoot);
+        if (!relation) {
+            return;
         }
-        else {
-            const [a2oCollection, a2oItemField, a2oCollectionField] = implicitRelation;
-            const relation = {
-                collection: a2oCollection,
-                field: a2oItemField,
-                related_collection: collection,
-                schema: null,
-                meta: {
-                    one_collection_field: a2oCollectionField,
-                    one_field: field,
-                },
-            };
-            return { relation, relationType: 'o2a' };
+        const alias = generateAlias();
+        (0, lodash_1.set)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts, alias);
+        if (relationType === 'm2o') {
+            rootQuery.leftJoin({ [alias]: relation.related_collection }, `${parentAlias || parentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
+        }
+        if (relationType === 'a2o') {
+            const pathScope = pathParts[0].split(':')[1];
+            if (!pathScope) {
+                throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+            }
+            rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
+                joinClause
+                    .onVal(relation.meta.one_collection_field, '=', pathScope)
+                    .andOn(`${parentAlias || parentCollection}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${alias}.${schema.collections[pathScope].primary}`));
+            });
+        }
+        if (relationType === 'o2a') {
+            rootQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
+                joinClause
+                    .onVal(relation.meta.one_collection_field, '=', parentCollection)
+                    .andOn(`${alias}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${parentAlias || parentCollection}.${schema.collections[parentCollection].primary}`));
+            });
+        }
+        // Still join o2m relations when in subquery OR when the o2m relation is not at the root level
+        if (relationType === 'o2m' && (subQuery === true || parentAlias !== undefined)) {
+            rootQuery.leftJoin({ [alias]: relation.collection }, `${parentAlias || parentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
+        }
+        if (relationType === 'm2o' || subQuery === true || (relationType === 'o2m' && parentAlias !== undefined)) {
+            let parent;
+            if (relationType === 'm2o') {
+                parent = relation.related_collection;
+            }
+            else if (relationType === 'a2o') {
+                const pathScope = pathParts[0].split(':')[1];
+                if (!pathScope) {
+                    throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+                }
+                parent = pathScope;
+            }
+            else {
+                parent = relation.collection;
+            }
+            pathParts.shift();
+            if (pathParts.length) {
+                followRelation(pathParts, parent, alias);
+            }
         }
     }
-    const relation = (_b = relations.find((relation) => {
-        var _a;
-        return ((relation.collection === collection && relation.field === field) ||
-            (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
-    })) !== null && _b !== void 0 ? _b : null;
-    const relationType = relation ? (0, get_relation_type_1.getRelationType)({ relation, collection, field }) : null;
-    return { relation, relationType };
 }
+function applySort(knex, schema, rootQuery, rootSort, collection, subQuery = false) {
+    const relations = schema.relations;
+    const aliasMap = {};
+    rootQuery.orderBy(rootSort.map((sortField) => {
+        const column = sortField.split('.');
+        let order = 'asc';
+        if (column.length > 1) {
+            if (sortField.startsWith('-')) {
+                order = 'desc';
+            }
+            if (column[0].startsWith('-')) {
+                column[0] = column[0].substring(1);
+            }
+            addJoin({
+                path: column,
+                collection,
+                aliasMap,
+                rootQuery,
+                subQuery,
+                schema,
+                relations,
+                knex,
+            });
+            const colPath = (0, get_column_path_1.getColumnPath)({ path: column, collection, aliasMap, relations }) || '';
+            const [alias, field] = colPath.split('.');
+            return {
+                order,
+                column: (0, get_column_1.getColumn)(knex, alias, field, false, schema),
+            };
+        }
+        let col = column[0];
+        if (sortField.startsWith('-')) {
+            col = column[0].substring(1);
+            order = 'desc';
+        }
+        return {
+            order,
+            column: (0, get_column_1.getColumn)(knex, collection, col, false, schema),
+        };
+    }));
+}
+exports.applySort = applySort;
 function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery = false) {
     const helpers = (0, helpers_1.getHelpers)(knex);
     const relations = schema.relations;
@@ -114,72 +169,21 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             }
             const filterPath = getFilterPath(key, value);
             if (filterPath.length > 1) {
-                addJoin(filterPath, collection);
-            }
-        }
-        function addJoin(path, collection) {
-            path = (0, lodash_1.clone)(path);
-            followRelation(path);
-            function followRelation(pathParts, parentCollection = collection, parentAlias) {
-                /**
-                 * For A2M fields, the path can contain an optional collection scope <field>:<scope>
-                 */
-                const pathRoot = pathParts[0].split(':')[0];
-                const { relation, relationType } = getRelationInfo(relations, parentCollection, pathRoot);
-                if (!relation) {
-                    return;
-                }
-                const alias = generateAlias();
-                (0, lodash_1.set)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts, alias);
-                if (relationType === 'm2o') {
-                    dbQuery.leftJoin({ [alias]: relation.related_collection }, `${parentAlias || parentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
-                }
-                if (relationType === 'a2o') {
-                    const pathScope = pathParts[0].split(':')[1];
-                    if (!pathScope) {
-                        throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);
-                    }
-                    dbQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
-                        joinClause
-                            .onVal(relation.meta.one_collection_field, '=', pathScope)
-                            .andOn(`${parentAlias || parentCollection}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${alias}.${schema.collections[pathScope].primary}`));
-                    });
-                }
-                if (relationType === 'o2a') {
-                    dbQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
-                        joinClause
-                            .onVal(relation.meta.one_collection_field, '=', parentCollection)
-                            .andOn(`${alias}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${parentAlias || parentCollection}.${schema.collections[parentCollection].primary}`));
-                    });
-                }
-                // Still join o2m relations when in subquery OR when the o2m relation is not at the root level
-                if (relationType === 'o2m' && (subQuery === true || parentAlias !== undefined)) {
-                    dbQuery.leftJoin({ [alias]: relation.collection }, `${parentAlias || parentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
-                }
-                if (relationType === 'm2o' || subQuery === true || (relationType === 'o2m' && parentAlias !== undefined)) {
-                    let parent;
-                    if (relationType === 'm2o') {
-                        parent = relation.related_collection;
-                    }
-                    else if (relationType === 'a2o') {
-                        const pathScope = pathParts[0].split(':')[1];
-                        if (!pathScope) {
-                            throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);
-                        }
-                        parent = pathScope;
-                    }
-                    else {
-                        parent = relation.collection;
-                    }
-                    pathParts.shift();
-                    if (pathParts.length) {
-                        followRelation(pathParts, parent, alias);
-                    }
-                }
+                addJoin({
+                    path: filterPath,
+                    collection,
+                    knex,
+                    schema,
+                    relations,
+                    subQuery,
+                    rootQuery,
+                    aliasMap,
+                });
             }
         }
     }
     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
@@ -200,11 +204,11 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
              * For A2M fields, the path can contain an optional collection scope <field>:<scope>
              */
             const pathRoot = filterPath[0].split(':')[0];
-            const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);
+            const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, collection, pathRoot);
             const { operator: filterOperator, value: filterValue } = getOperation(key, value);
             if (relationType === 'm2o' || relationType === 'a2o' || relationType === null) {
                 if (filterPath.length > 1) {
-                    const columnName = getWhereColumn(filterPath, collection);
+                    const columnName = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
                     if (!columnName)
                         continue;
                     applyFilterToQuery(columnName, filterOperator, filterValue, logical);
@@ -220,16 +224,25 @@ 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') {
@@ -372,41 +385,6 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
             }
         }
-        function getWhereColumn(path, collection) {
-            return followRelation(path);
-            function followRelation(pathParts, parentCollection = collection, parentAlias) {
-                /**
-                 * For A2M fields, the path can contain an optional collection scope <field>:<scope>
-                 */
-                const pathRoot = pathParts[0].split(':')[0];
-                const { relation, relationType } = getRelationInfo(relations, parentCollection, pathRoot);
-                if (!relation) {
-                    throw new exceptions_1.InvalidQueryException(`"${parentCollection}.${pathRoot}" is not a relational field`);
-                }
-                const alias = (0, lodash_1.get)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts);
-                const remainingParts = pathParts.slice(1);
-                let parent;
-                if (relationType === 'a2o') {
-                    const pathScope = pathParts[0].split(':')[1];
-                    if (!pathScope) {
-                        throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);
-                    }
-                    parent = pathScope;
-                }
-                else if (relationType === 'm2o') {
-                    parent = relation.related_collection;
-                }
-                else {
-                    parent = relation.collection;
-                }
-                if (remainingParts.length === 1) {
-                    return `${alias || parent}.${remainingParts[0]}`;
-                }
-                if (remainingParts.length) {
-                    return followRelation(remainingParts, parent, alias);
-                }
-            }
-        }
     }
 }
 exports.applyFilter = applyFilter;

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-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 {};

package/dist/utils/get-column-path.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnPath = void 0;
+const get_relation_info_1 = require("./get-relation-info");
+const exceptions_1 = require("../exceptions");
+const lodash_1 = require("lodash");
+/**
+ * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
+ * For example: ['author', 'role', 'name'] -> 'ljnsv.name'
+ */
+function getColumnPath({ path, collection, aliasMap, relations }) {
+    return followRelation(path);
+    function followRelation(pathParts, parentCollection = collection, parentAlias) {
+        /**
+         * For A2M fields, the path can contain an optional collection scope <field>:<scope>
+         */
+        const pathRoot = pathParts[0].split(':')[0];
+        const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, parentCollection, pathRoot);
+        if (!relation) {
+            throw new exceptions_1.InvalidQueryException(`"${parentCollection}.${pathRoot}" is not a relational field`);
+        }
+        const alias = (0, lodash_1.get)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts);
+        const remainingParts = pathParts.slice(1);
+        let parent;
+        if (relationType === 'a2o') {
+            const pathScope = pathParts[0].split(':')[1];
+            if (!pathScope) {
+                throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when sorting on a many-to-any item`);
+            }
+            parent = pathScope;
+        }
+        else if (relationType === 'm2o') {
+            parent = relation.related_collection;
+        }
+        else {
+            parent = relation.collection;
+        }
+        if (remainingParts.length === 1) {
+            return `${alias || parent}.${remainingParts[0]}`;
+        }
+        if (remainingParts.length) {
+            return followRelation(remainingParts, parent, alias);
+        }
+    }
+}
+exports.getColumnPath = getColumnPath;

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-relation-info.d.ts

@@ -0,0 +1,7 @@
+import { Relation } from '@directus/shared/types';
+declare type RelationInfo = {
+    relation: Relation | null;
+    relationType: string | null;
+};
+export declare function getRelationInfo(relations: Relation[], collection: string, field: string): RelationInfo;
+export {};

package/dist/utils/get-relation-info.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelationInfo = void 0;
+const get_relation_type_1 = require("./get-relation-type");
+function getRelationInfo(relations, collection, field) {
+    var _a, _b;
+    if (field.startsWith('$FOLLOW') && field.length > 500) {
+        throw new Error(`Implicit $FOLLOW statement is too big to parse. Got: "${field.substring(500)}..."`);
+    }
+    const implicitRelation = (_a = field.match(/^\$FOLLOW\((.*?),(.*?)(?:,(.*?))?\)$/)) === null || _a === void 0 ? void 0 : _a.slice(1);
+    if (implicitRelation) {
+        if (implicitRelation[2] === undefined) {
+            const [m2oCollection, m2oField] = implicitRelation;
+            const relation = {
+                collection: m2oCollection.trim(),
+                field: m2oField.trim(),
+                related_collection: collection,
+                schema: null,
+                meta: null,
+            };
+            return { relation, relationType: 'o2m' };
+        }
+        else {
+            const [a2oCollection, a2oItemField, a2oCollectionField] = implicitRelation;
+            const relation = {
+                collection: a2oCollection.trim(),
+                field: a2oItemField.trim(),
+                related_collection: collection,
+                schema: null,
+                meta: {
+                    one_collection_field: a2oCollectionField.trim(),
+                },
+            };
+            return { relation, relationType: 'o2a' };
+        }
+    }
+    const relation = (_b = relations.find((relation) => {
+        var _a;
+        return ((relation.collection === collection && relation.field === field) ||
+            (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
+    })) !== null && _b !== void 0 ? _b : null;
+    const relationType = relation ? (0, get_relation_type_1.getRelationType)({ relation, collection, field }) : null;
+    return { relation, relationType };
+}
+exports.getRelationInfo = getRelationInfo;

package/dist/utils/get-relation-type.d.ts

@@ -1,6 +1,6 @@
 import { Relation } from '@directus/shared/types';
 export declare function getRelationType(getRelationOptions: {
-    relation: Relation;
+    relation?: Relation | null;
     collection: string | null;
     field: string;
 }): 'm2o' | 'o2m' | 'a2o' | null;

package/dist/utils/get-schema.js

@@ -8,6 +8,7 @@ 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");
@@ -113,6 +114,8 @@ 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')