directus 9.21.0 → 9.22.0

package/dist/storage/index.test.d.ts

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

package/dist/storage/register-drivers.d.ts

@@ -0,0 +1,2 @@
+import type { StorageManager } from '@directus/storage';
+export declare const registerDrivers: (storage: StorageManager) => Promise<void>;

package/dist/storage/register-drivers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDrivers = void 0;
+const env_1 = require("../env");
+const get_storage_driver_1 = require("./get-storage-driver");
+const registerDrivers = async (storage) => {
+    const env = (0, env_1.getEnv)();
+    const usedDrivers = [];
+    for (const [key, value] of Object.entries(env)) {
+        if ((key.startsWith('STORAGE_') && key.endsWith('_DRIVER')) === false)
+            continue;
+        if (value && usedDrivers.includes(value) === false)
+            usedDrivers.push(value);
+    }
+    for (const driverName of usedDrivers) {
+        const storageDriver = await (0, get_storage_driver_1.getStorageDriver)(driverName);
+        if (storageDriver) {
+            storage.registerDriver(driverName, storageDriver);
+        }
+    }
+};
+exports.registerDrivers = registerDrivers;

package/dist/storage/register-drivers.test.d.ts

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

package/dist/storage/register-locations.d.ts

@@ -0,0 +1,2 @@
+import type { StorageManager } from '@directus/storage';
+export declare const registerLocations: (storage: StorageManager) => Promise<void>;

package/dist/storage/register-locations.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLocations = void 0;
+const utils_1 = require("@directus/shared/utils");
+const env_1 = require("../env");
+const get_config_from_env_1 = require("../utils/get-config-from-env");
+const registerLocations = async (storage) => {
+    const env = (0, env_1.getEnv)();
+    const locations = (0, utils_1.toArray)(env.STORAGE_LOCATIONS);
+    locations.forEach((location) => {
+        location = location.trim();
+        const driverConfig = (0, get_config_from_env_1.getConfigFromEnv)(`STORAGE_${location.toUpperCase()}_`);
+        const { driver, ...options } = driverConfig;
+        storage.registerLocation(location, { driver, options });
+    });
+};
+exports.registerLocations = registerLocations;

package/dist/storage/register-locations.test.d.ts

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

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

@@ -1,10 +1,34 @@
 import { Aggregate, Filter, Query, SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
+import { AliasMap } from './get-column-path';
+export declare const generateAlias: () => string;
 /**
  * Apply the Query to a given Knex query builder instance
  */
-export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, subQuery?: boolean): Knex.QueryBuilder;
-export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootSort: string[], collection: string, subQuery?: boolean): void;
-export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, subQuery?: boolean): Knex.QueryBuilder<any, any>;
+export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, options?: {
+    aliasMap?: AliasMap;
+    isInnerQuery?: boolean;
+    hasMultiRelationalSort?: boolean;
+}): {
+    query: Knex.QueryBuilder<any, any>;
+    hasMultiRelationalFilter: boolean;
+};
+export type ColumnSortRecord = {
+    order: 'asc' | 'desc';
+    column: string;
+};
+export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootSort: string[], collection: string, aliasMap: AliasMap, returnRecords?: boolean): {
+    sortRecords: {
+        order: "asc" | "desc";
+        column: any;
+    }[];
+    hasMultiRelationalSort: boolean;
+} | undefined;
+export declare function applyLimit(rootQuery: Knex.QueryBuilder, limit: any): void;
+export declare function applyOffset(knex: Knex, rootQuery: Knex.QueryBuilder, offset: any): void;
+export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, aliasMap: AliasMap): {
+    query: Knex.QueryBuilder<any, any>;
+    hasMultiRelationalFilter: boolean;
+};
 export declare function applySearch(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): Promise<void>;
 export declare function applyAggregate(dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string): void;

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) {