directus 9.21.2 → 9.22.1

package/dist/utils/apply-query.js

@@ -3,9 +3,8 @@ 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 = exports.applySort = void 0;
+exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.applyOffset = exports.applyLimit = exports.applySort = exports.generateAlias = void 0;
 const lodash_1 = require("lodash");
-const nanoid_1 = require("nanoid");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
 const helpers_1 = require("../database/helpers");
 const invalid_query_1 = require("../exceptions/invalid-query");
@@ -14,19 +13,24 @@ const get_column_path_1 = require("./get-column-path");
 const get_relation_info_1 = require("./get-relation-info");
 const utils_1 = require("@directus/shared/utils");
 const strip_function_1 = require("./strip-function");
-const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
+// @ts-ignore
+const non_secure_1 = require("nanoid/non-secure");
+exports.generateAlias = (0, non_secure_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) {
-        applySort(knex, schema, dbQuery, query.sort, collection, subQuery);
+function applyQuery(knex, collection, dbQuery, query, schema, options) {
+    var _a;
+    const aliasMap = (_a = options === null || options === void 0 ? void 0 : options.aliasMap) !== null && _a !== void 0 ? _a : Object.create(null);
+    let hasMultiRelationalFilter = false;
+    if (query.sort && !(options === null || options === void 0 ? void 0 : options.isInnerQuery) && !(options === null || options === void 0 ? void 0 : options.hasMultiRelationalSort)) {
+        applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
     }
-    if (typeof query.limit === 'number' && query.limit !== -1) {
-        dbQuery.limit(query.limit);
+    if (!(options === null || options === void 0 ? void 0 : options.hasMultiRelationalSort)) {
+        applyLimit(dbQuery, query.limit);
     }
     if (query.offset) {
-        dbQuery.offset(query.offset);
+        applyOffset(knex, dbQuery, query.offset);
     }
     if (query.page && query.limit && query.limit !== -1) {
         dbQuery.offset(query.limit * (query.page - 1));
@@ -41,15 +45,18 @@ function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false)
         applyAggregate(dbQuery, query.aggregate, collection);
     }
     if (query.filter) {
-        applyFilter(knex, schema, dbQuery, query.filter, collection, subQuery);
+        hasMultiRelationalFilter = applyFilter(knex, schema, dbQuery, query.filter, collection, aliasMap).hasMultiRelationalFilter;
     }
-    return dbQuery;
+    return { query: dbQuery, hasMultiRelationalFilter };
 }
 exports.default = applyQuery;
-function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, relations, knex }) {
+function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, knex }) {
+    let hasMultiRelational = false;
     path = (0, lodash_1.clone)(path);
     followRelation(path);
-    function followRelation(pathParts, parentCollection = collection, parentAlias) {
+    return hasMultiRelational;
+    function followRelation(pathParts, parentCollection = collection, parentFields) {
+        var _a, _b, _c;
         /**
          * For A2M fields, the path can contain an optional collection scope <field>:<scope>
          */
@@ -58,104 +65,135 @@ function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, rela
         if (!relation) {
             return;
         }
-        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 invalid_query_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;
+        const existingAlias = parentFields
+            ? (_a = aliasMap[`${parentFields}.${pathParts[0]}`]) === null || _a === void 0 ? void 0 : _a.alias
+            : (_b = aliasMap[pathParts[0]]) === null || _b === void 0 ? void 0 : _b.alias;
+        if (!existingAlias) {
+            const alias = (0, exports.generateAlias)();
+            const aliasKey = parentFields ? `${parentFields}.${pathParts[0]}` : pathParts[0];
+            const aliasedParentCollection = ((_c = aliasMap[parentFields !== null && parentFields !== void 0 ? parentFields : '']) === null || _c === void 0 ? void 0 : _c.alias) || parentCollection;
+            aliasMap[aliasKey] = { alias, collection: '' };
             if (relationType === 'm2o') {
-                parent = relation.related_collection;
+                rootQuery.leftJoin({ [alias]: relation.related_collection }, `${aliasedParentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
+                aliasMap[aliasKey].collection = relation.related_collection;
             }
             else if (relationType === 'a2o') {
                 const pathScope = pathParts[0].split(':')[1];
                 if (!pathScope) {
                     throw new invalid_query_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
                 }
-                parent = pathScope;
+                rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
+                    joinClause
+                        .onVal(relation.meta.one_collection_field, '=', pathScope)
+                        .andOn(`${aliasedParentCollection}.${relation.field}`, '=', knex.raw((0, helpers_1.getHelpers)(knex).schema.castA2oPrimaryKey(), `${alias}.${schema.collections[pathScope].primary}`));
+                });
+                aliasMap[aliasKey].collection = pathScope;
             }
-            else {
-                parent = relation.collection;
+            else if (relationType === 'o2a') {
+                rootQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
+                    joinClause
+                        .onVal(relation.meta.one_collection_field, '=', parentCollection)
+                        .andOn(`${alias}.${relation.field}`, '=', knex.raw((0, helpers_1.getHelpers)(knex).schema.castA2oPrimaryKey(), `${aliasedParentCollection}.${schema.collections[parentCollection].primary}`));
+                });
+                aliasMap[aliasKey].collection = relation.collection;
+                hasMultiRelational = true;
             }
-            pathParts.shift();
-            if (pathParts.length) {
-                followRelation(pathParts, parent, alias);
+            else if (relationType === 'o2m') {
+                rootQuery.leftJoin({ [alias]: relation.collection }, `${aliasedParentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
+                aliasMap[aliasKey].collection = relation.collection;
+                hasMultiRelational = true;
             }
         }
+        let parent;
+        if (relationType === 'm2o') {
+            parent = relation.related_collection;
+        }
+        else if (relationType === 'a2o') {
+            const pathScope = pathParts[0].split(':')[1];
+            if (!pathScope) {
+                throw new invalid_query_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;
+        }
+        if (pathParts.length > 1) {
+            followRelation(pathParts.slice(1), parent, `${parentFields ? parentFields + '.' : ''}${pathParts[0]}`);
+        }
     }
 }
-function applySort(knex, schema, rootQuery, rootSort, collection, subQuery = false) {
+function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, returnRecords = false) {
     const relations = schema.relations;
-    const aliasMap = {};
-    rootQuery.orderBy(rootSort.map((sortField) => {
+    let hasMultiRelationalSort = false;
+    const sortRecords = 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 { 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),
-            };
-        }
-        let col = column[0];
         if (sortField.startsWith('-')) {
-            col = column[0].substring(1);
             order = 'desc';
         }
+        if (column[0].startsWith('-')) {
+            column[0] = column[0].substring(1);
+        }
+        if (column.length === 1) {
+            const pathRoot = column[0].split(':')[0];
+            const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, collection, pathRoot);
+            if (!relation || ['m2o', 'a2o'].includes(relationType !== null && relationType !== void 0 ? relationType : '')) {
+                return {
+                    order,
+                    column: returnRecords ? column[0] : (0, get_column_1.getColumn)(knex, collection, column[0], false, schema),
+                };
+            }
+        }
+        const hasMultiRelational = addJoin({
+            path: column,
+            collection,
+            aliasMap,
+            rootQuery,
+            schema,
+            relations,
+            knex,
+        });
+        const { columnPath } = (0, get_column_path_1.getColumnPath)({
+            path: column,
+            collection,
+            aliasMap,
+            relations,
+            schema,
+        });
+        const [alias, field] = columnPath.split('.');
+        if (!hasMultiRelationalSort) {
+            hasMultiRelationalSort = hasMultiRelational;
+        }
         return {
             order,
-            column: (0, get_column_1.getColumn)(knex, collection, col, false, schema),
+            column: returnRecords ? columnPath : (0, get_column_1.getColumn)(knex, alias, field, false, schema),
         };
-    }));
+    });
+    if (returnRecords)
+        return { sortRecords, hasMultiRelationalSort };
+    rootQuery.orderBy(sortRecords);
 }
 exports.applySort = applySort;
-function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery = false) {
+function applyLimit(rootQuery, limit) {
+    if (typeof limit === 'number' && limit !== -1) {
+        rootQuery.limit(limit);
+    }
+}
+exports.applyLimit = applyLimit;
+function applyOffset(knex, rootQuery, offset) {
+    if (typeof offset === 'number') {
+        (0, helpers_1.getHelpers)(knex).schema.applyOffset(rootQuery, offset);
+    }
+}
+exports.applyOffset = applyOffset;
+function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap) {
     const helpers = (0, helpers_1.getHelpers)(knex);
     const relations = schema.relations;
-    const aliasMap = {};
+    let hasMultiRelationalFilter = false;
     addJoins(rootQuery, rootFilter, collection);
     addWhereClauses(knex, rootQuery, rootFilter, collection);
-    return rootQuery;
+    return { query: rootQuery, hasMultiRelationalFilter };
     function addJoins(dbQuery, filter, collection) {
         for (const [key, value] of Object.entries(filter)) {
             if (key === '_or' || key === '_and') {
@@ -169,22 +207,25 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 continue;
             }
             const filterPath = getFilterPath(key, value);
-            if (filterPath.length > 1) {
-                addJoin({
+            if (filterPath.length > 1 ||
+                (!(key.includes('(') && key.includes(')')) && schema.collections[collection].fields[key].type === 'alias')) {
+                const hasMultiRelational = addJoin({
                     path: filterPath,
                     collection,
                     knex,
                     schema,
                     relations,
-                    subQuery,
                     rootQuery,
                     aliasMap,
                 });
+                if (!hasMultiRelationalFilter) {
+                    hasMultiRelationalFilter = hasMultiRelational;
+                }
             }
         }
     }
     function addWhereClauses(knex, dbQuery, filter, collection, logical = 'and') {
-        var _a, _b;
+        var _a;
         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
@@ -207,47 +248,58 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             const pathRoot = filterPath[0].split(':')[0];
             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 { columnPath, targetCollection } = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
-                    if (!columnPath)
-                        continue;
-                    const { type, special } = validateFilterField(schema.collections[targetCollection].fields, (0, strip_function_1.stripFunction)(filterPath[filterPath.length - 1]), targetCollection);
-                    validateFilterOperator(type, filterOperator, special);
-                    applyFilterToQuery(columnPath, filterOperator, filterValue, logical, targetCollection);
-                }
-                else {
-                    const { type, special } = validateFilterField(schema.collections[collection].fields, (0, strip_function_1.stripFunction)(filterPath[0]), collection);
-                    validateFilterOperator(type, filterOperator, special);
-                    applyFilterToQuery(`${collection}.${filterPath[0]}`, filterOperator, filterValue, logical);
-                }
-            }
-            else if (subQuery === false || filterPath.length > 1) {
+            if (filterPath.length > 1 ||
+                (!(key.includes('(') && key.includes(')')) && schema.collections[collection].fields[key].type === 'alias')) {
                 if (!relation)
                     continue;
-                let pkField = `${collection}.${schema.collections[relation.related_collection].primary}`;
-                if (relationType === 'o2a') {
-                    pkField = knex.raw(`CAST(?? AS CHAR(255))`, [pkField]);
-                }
-                const subQueryBuilder = (filter) => (subQueryKnex) => {
-                    const field = relation.field;
-                    const collection = relation.collection;
-                    const column = `${collection}.${field}`;
-                    subQueryKnex
-                        .select({ [field]: column })
-                        .from(collection)
-                        .whereNotNull(column);
-                    applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema, true);
-                };
-                if (((_a = Object.keys(value)) === null || _a === void 0 ? void 0 : _a[0]) === '_none') {
-                    dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0]));
+                if (relationType === 'o2m' || relationType === 'o2a') {
+                    let pkField = `${collection}.${schema.collections[relation.related_collection].primary}`;
+                    if (relationType === 'o2a') {
+                        pkField = knex.raw((0, helpers_1.getHelpers)(knex).schema.castA2oPrimaryKey(), [pkField]);
+                    }
+                    const subQueryBuilder = (filter) => (subQueryKnex) => {
+                        const field = relation.field;
+                        const collection = relation.collection;
+                        const column = `${collection}.${field}`;
+                        subQueryKnex
+                            .select({ [field]: column })
+                            .from(collection)
+                            .whereNotNull(column);
+                        applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema);
+                    };
+                    const childKey = (_a = Object.keys(value)) === null || _a === void 0 ? void 0 : _a[0];
+                    if (childKey === '_none') {
+                        dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0]));
+                        continue;
+                    }
+                    else if (childKey === '_some') {
+                        dbQuery[logical].whereIn(pkField, subQueryBuilder(Object.values(value)[0]));
+                        continue;
+                    }
                 }
-                else if (((_b = Object.keys(value)) === null || _b === void 0 ? void 0 : _b[0]) === '_some') {
-                    dbQuery[logical].whereIn(pkField, subQueryBuilder(Object.values(value)[0]));
+                if (filterPath.includes('_none') || filterPath.includes('_some')) {
+                    throw new invalid_query_1.InvalidQueryException(`"${filterPath.includes('_none') ? '_none' : '_some'}" can only be used with top level relational alias field`);
                 }
-                else {
-                    dbQuery[logical].whereIn(pkField, subQueryBuilder(value));
+                const { columnPath, targetCollection, addNestedPkField } = (0, get_column_path_1.getColumnPath)({
+                    path: filterPath,
+                    collection,
+                    relations,
+                    aliasMap,
+                    schema,
+                });
+                if (addNestedPkField) {
+                    filterPath.push(addNestedPkField);
                 }
+                if (!columnPath)
+                    continue;
+                const { type, special } = validateFilterField(schema.collections[targetCollection].fields, (0, strip_function_1.stripFunction)(filterPath[filterPath.length - 1]), targetCollection);
+                validateFilterOperator(type, filterOperator, special);
+                applyFilterToQuery(columnPath, filterOperator, filterValue, logical, targetCollection);
+            }
+            else {
+                const { type, special } = validateFilterField(schema.collections[collection].fields, (0, strip_function_1.stripFunction)(filterPath[0]), collection);
+                validateFilterOperator(type, filterOperator, special);
+                applyFilterToQuery(`${collection}.${filterPath[0]}`, filterOperator, filterValue, logical);
             }
         }
         function validateFilterField(fields, key, collection = 'unknown') {
@@ -271,7 +323,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
         function applyFilterToQuery(key, operator, compareValue, logical = 'and', originalCollectionName) {
             const [table, column] = key.split('.');
             // Is processed through Knex.Raw, so should be safe to string-inject into these where queries
-            const selectionRaw = (0, get_column_1.getColumn)(knex, table, column, false, schema);
+            const selectionRaw = (0, get_column_1.getColumn)(knex, table, column, false, schema, { originalCollectionName });
             // Knex supports "raw" in the columnName parameter, but isn't typed as such. Too bad..
             // See https://github.com/knex/knex/issues/4518 @TODO remove as any once knex is updated
             // These operators don't rely on a value, and can thus be used without one (eg `?filter[field][_null]`)
@@ -498,16 +550,17 @@ function applyAggregate(dbQuery, aggregate, collection) {
 exports.applyAggregate = applyAggregate;
 function getFilterPath(key, value) {
     const path = [key];
-    if (typeof Object.keys(value)[0] === 'string' && Object.keys(value)[0].startsWith('_') === true) {
+    const childKey = Object.keys(value)[0];
+    if (typeof childKey === 'string' && childKey.startsWith('_') === true && !['_none', '_some'].includes(childKey)) {
         return path;
     }
     if ((0, lodash_1.isPlainObject)(value)) {
-        path.push(...getFilterPath(Object.keys(value)[0], Object.values(value)[0]));
+        path.push(...getFilterPath(childKey, Object.values(value)[0]));
     }
     return path;
 }
 function getOperation(key, value) {
-    if (key.startsWith('_') && key !== '_and' && key !== '_or') {
+    if (key.startsWith('_') && !['_and', '_or', '_none', '_some'].includes(key)) {
         return { operator: key, value };
     }
     else if ((0, lodash_1.isPlainObject)(value) === false) {

package/dist/utils/dynamic-import.d.ts

@@ -0,0 +1 @@
+export declare const dynamicImport: (mod: string) => Promise<any>;

package/dist/utils/dynamic-import.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicImport = void 0;
+const dynamicImport = async (mod) => {
+    return process.env.VITEST ? await import(mod) : require(mod);
+};
+exports.dynamicImport = dynamicImport;

package/dist/utils/get-collection-from-alias.d.ts

@@ -0,0 +1,6 @@
+import { AliasMap } from './get-column-path';
+/**
+ * Extract the collection of an alias within an aliasMap
+ * For example: 'ljnsv.name' -> 'authors'
+ */
+export declare function getCollectionFromAlias(alias: string, aliasMap: AliasMap): string | undefined;

package/dist/utils/get-collection-from-alias.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCollectionFromAlias = void 0;
+/**
+ * Extract the collection of an alias within an aliasMap
+ * For example: 'ljnsv.name' -> 'authors'
+ */
+function getCollectionFromAlias(alias, aliasMap) {
+    for (const aliasValue of Object.values(aliasMap)) {
+        if (aliasValue.alias === alias) {
+            return aliasValue.collection;
+        }
+    }
+}
+exports.getCollectionFromAlias = getCollectionFromAlias;

package/dist/utils/get-collection-from-alias.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,20 +1,26 @@
-import { Relation } from '@directus/shared/types';
-type AliasMap = string | {
-    [key: string]: AliasMap;
+import { Relation, SchemaOverview } from '@directus/shared/types';
+export type AliasMap = {
+    [key: string]: {
+        alias: string;
+        collection: string;
+    };
 };
 export type ColPathProps = {
     path: string[];
     collection: string;
     aliasMap: AliasMap;
     relations: Relation[];
+    schema?: SchemaOverview;
+};
+export type ColPathResult = {
+    columnPath: string;
+    targetCollection: string;
+    addNestedPkField?: string;
 };
 /**
  * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
  * For example: ['author', 'role', 'name'] -> 'ljnsv.name'
  * Also returns the target collection of the column: 'directus_roles'
+ * If the last filter path is an alias field, a nested PK is appended to the path
  */
-export declare function getColumnPath({ path, collection, aliasMap, relations }: ColPathProps): {
-    columnPath: string;
-    targetCollection: string;
-};
-export {};
+export declare function getColumnPath({ path, collection, aliasMap, relations, schema }: ColPathProps): ColPathResult;

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

@@ -3,15 +3,16 @@ 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'
  * Also returns the target collection of the column: 'directus_roles'
+ * If the last filter path is an alias field, a nested PK is appended to the path
  */
-function getColumnPath({ path, collection, aliasMap, relations }) {
+function getColumnPath({ path, collection, aliasMap, relations, schema }) {
     return followRelation(path);
-    function followRelation(pathParts, parentCollection = collection, parentAlias) {
+    function followRelation(pathParts, parentCollection = collection, parentFields, addNestedPkField) {
+        var _a, _b, _c, _d;
         /**
          * For A2M fields, the path can contain an optional collection scope <field>:<scope>
          */
@@ -20,7 +21,7 @@ function getColumnPath({ path, collection, aliasMap, relations }) {
         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 alias = parentFields ? (_a = aliasMap[`${parentFields}.${pathParts[0]}`]) === null || _a === void 0 ? void 0 : _a.alias : (_b = aliasMap[pathParts[0]]) === null || _b === void 0 ? void 0 : _b.alias;
         const remainingParts = pathParts.slice(1);
         let parent;
         if (relationType === 'a2o') {
@@ -36,13 +37,29 @@ function getColumnPath({ path, collection, aliasMap, relations }) {
         else {
             parent = relation.collection;
         }
+        // Top level alias field
+        if (schema && !(((_c = remainingParts[0]) !== null && _c !== void 0 ? _c : parent).includes('(') && ((_d = remainingParts[0]) !== null && _d !== void 0 ? _d : parent).includes(')'))) {
+            if (remainingParts.length === 0) {
+                remainingParts.push(schema.collections[parent].primary);
+                addNestedPkField = schema.collections[parent].primary;
+            }
+            // Nested level alias field
+            else if (remainingParts.length === 1 && schema.collections[parent].fields[remainingParts[0]].type === 'alias') {
+                remainingParts.push(schema.collections[relation.related_collection].primary);
+                addNestedPkField = schema.collections[relation.related_collection].primary;
+            }
+        }
         if (remainingParts.length === 1) {
-            return { columnPath: `${alias || parent}.${remainingParts[0]}`, targetCollection: parent };
+            return {
+                columnPath: `${alias || parent}.${remainingParts[0]}`,
+                targetCollection: parent,
+                addNestedPkField,
+            };
         }
         if (remainingParts.length) {
-            return followRelation(remainingParts, parent, alias);
+            return followRelation(remainingParts, parent, `${parentFields ? parentFields + '.' : ''}${pathParts[0]}`, addNestedPkField);
         }
-        return { columnPath: '', targetCollection: '' };
+        return { columnPath: '', targetCollection: '', addNestedPkField };
     }
 }
 exports.getColumnPath = getColumnPath;

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

@@ -1,5 +1,9 @@
 import { Query, SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
+type GetColumnOptions = {
+    query?: Query;
+    originalCollectionName?: string;
+};
 /**
  * Return column prefixed by table. If column includes functions (like `year(date_created)`), the
  * column is replaced with the appropriate SQL
@@ -8,6 +12,9 @@ import { Knex } from 'knex';
  * @param table Collection or alias in which column resides
  * @param column name of the column
  * @param alias Whether or not to add a SQL AS statement
+ * @param schema For retrieval of the column type
+ * @param options Optional parameters
  * @returns Knex raw instance
  */
-export declare function getColumn(knex: Knex, table: string, column: string, alias: string | false | undefined, schema: SchemaOverview, query?: Query): Knex.Raw;
+export declare function getColumn(knex: Knex, table: string, column: string, alias: string | false | undefined, schema: SchemaOverview, options?: GetColumnOptions): Knex.Raw;
+export {};

package/dist/utils/get-column.js

@@ -14,21 +14,28 @@ const apply_function_to_column_name_1 = require("./apply-function-to-column-name
  * @param table Collection or alias in which column resides
  * @param column name of the column
  * @param alias Whether or not to add a SQL AS statement
+ * @param schema For retrieval of the column type
+ * @param options Optional parameters
  * @returns Knex raw instance
  */
-function getColumn(knex, table, column, alias = (0, apply_function_to_column_name_1.applyFunctionToColumnName)(column), schema, query) {
+function getColumn(knex, table, column, alias = (0, apply_function_to_column_name_1.applyFunctionToColumnName)(column), schema, options) {
     var _a, _b, _c, _d;
     const fn = (0, helpers_1.getFunctions)(knex, schema);
     if (column.includes('(') && column.includes(')')) {
         const functionName = column.split('(')[0];
         const columnName = column.match(constants_1.REGEX_BETWEEN_PARENS)[1];
         if (functionName in fn) {
-            const type = (_d = (_c = (_b = (_a = schema === null || schema === void 0 ? void 0 : schema.collections[table]) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b[columnName]) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : 'unknown';
+            const collectionName = (options === null || options === void 0 ? void 0 : options.originalCollectionName) || table;
+            const type = (_d = (_c = (_b = (_a = schema === null || schema === void 0 ? void 0 : schema.collections[collectionName]) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b[columnName]) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : 'unknown';
             const allowedFunctions = (0, utils_1.getFunctionsForType)(type);
             if (allowedFunctions.includes(functionName) === false) {
                 throw new exceptions_1.InvalidQueryException(`Invalid function specified "${functionName}"`);
             }
-            const result = fn[functionName](table, columnName, { type, query });
+            const result = fn[functionName](table, columnName, {
+                type,
+                query: options === null || options === void 0 ? void 0 : options.query,
+                originalCollectionName: options === null || options === void 0 ? void 0 : options.originalCollectionName,
+            });
             if (alias) {
                 return knex.raw(result + ' AS ??', [alias]);
             }

package/dist/utils/get-config-from-env.js

@@ -6,10 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfigFromEnv = void 0;
 const camelcase_1 = __importDefault(require("camelcase"));
 const lodash_1 = require("lodash");
-const env_1 = __importDefault(require("../env"));
+const env_1 = require("../env");
 function getConfigFromEnv(prefix, omitPrefix, type = 'camelcase') {
+    const env = (0, env_1.getEnv)();
     const config = {};
-    for (const [key, value] of Object.entries(env_1.default)) {
+    for (const [key, value] of Object.entries(env)) {
         if (key.toLowerCase().startsWith(prefix.toLowerCase()) === false)
             continue;
         if (omitPrefix) {

package/dist/utils/get-default-value.d.ts

@@ -1,3 +1,3 @@
-import { SchemaOverview } from '@directus/schema/dist/types/overview';
+import { SchemaOverview } from '@directus/schema/types/overview';
 import { Column } from 'knex-schema-inspector/dist/types/column';
 export default function getDefaultValue(column: SchemaOverview[string]['columns'][string] | Column): string | boolean | number | Record<string, any> | any[] | null;

package/dist/utils/parse-image-metadata.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare function parseIptc(buffer: Buffer): Record<string, unknown>;
+export declare function parseXmp(buffer: Buffer): Record<string, unknown>;