@directus/api 26.0.1 → 27.0.1

package/dist/database/run-ast/lib/apply-query/search.js

@@ -0,0 +1,78 @@
+import { NUMERIC_TYPES } from '@directus/constants';
+import { isIn } from '@directus/utils';
+import { getCases } from '../../../../permissions/modules/process-ast/lib/get-cases.js';
+import { isValidUuid } from '../../../../utils/is-valid-uuid.js';
+import { parseNumericString } from '../../../../utils/parse-numeric-string.js';
+import { getHelpers } from '../../../helpers/index.js';
+import { applyFilter } from './filter/index.js';
+export function applySearch(knex, schema, dbQuery, searchQuery, collection, aliasMap, permissions) {
+    const { number: numberHelper } = getHelpers(knex);
+    const allowedFields = new Set(permissions.filter((p) => p.collection === collection).flatMap((p) => p.fields ?? []));
+    let fields = Object.entries(schema.collections[collection].fields);
+    const { cases, caseMap } = getCases(collection, permissions, []);
+    // Add field restrictions if non-admin and "everything" is not allowed
+    if (cases.length !== 0 && !allowedFields.has('*')) {
+        fields = fields.filter((field) => allowedFields.has(field[0]));
+    }
+    dbQuery.andWhere(function (queryBuilder) {
+        let needsFallbackCondition = true;
+        fields.forEach(([name, field]) => {
+            // only account for when cases when full access is not given
+            const whenCases = allowedFields.has('*') ? [] : (caseMap[name] ?? []).map((caseIndex) => cases[caseIndex]);
+            const fieldType = getFieldType(field);
+            if (fieldType !== null) {
+                needsFallbackCondition = false;
+            }
+            else {
+                return;
+            }
+            if (cases.length !== 0 && whenCases?.length !== 0) {
+                queryBuilder.orWhere((subQuery) => {
+                    addSearchCondition(subQuery, name, fieldType, 'and');
+                    applyFilter(knex, schema, subQuery, { _or: whenCases }, collection, aliasMap, cases, permissions);
+                });
+            }
+            else {
+                addSearchCondition(queryBuilder, name, fieldType, 'or');
+            }
+        });
+        if (needsFallbackCondition) {
+            queryBuilder.orWhereRaw('1 = 0');
+        }
+    });
+    function addSearchCondition(queryBuilder, name, fieldType, logical) {
+        if (fieldType === null) {
+            return;
+        }
+        if (fieldType === 'string') {
+            queryBuilder[logical].whereRaw(`LOWER(??) LIKE ?`, [`${collection}.${name}`, `%${searchQuery.toLowerCase()}%`]);
+        }
+        else if (fieldType === 'numeric') {
+            numberHelper.addSearchCondition(queryBuilder, collection, name, parseNumericString(searchQuery), logical);
+        }
+        else if (fieldType === 'uuid') {
+            queryBuilder[logical].where({ [`${collection}.${name}`]: searchQuery });
+        }
+    }
+    function getFieldType(field) {
+        if (['text', 'string'].includes(field.type)) {
+            return 'string';
+        }
+        if (isNumericField(field)) {
+            const number = parseNumericString(searchQuery);
+            if (number === null) {
+                return null;
+            }
+            if (numberHelper.isNumberValid(number, field)) {
+                return 'numeric';
+            }
+        }
+        if (field.type === 'uuid' && isValidUuid(searchQuery)) {
+            return 'uuid';
+        }
+        return null;
+    }
+}
+function isNumericField(field) {
+    return isIn(field.type, NUMERIC_TYPES);
+}

package/dist/database/run-ast/lib/apply-query/sort.d.ts

@@ -0,0 +1,19 @@
+import type { Aggregate, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AliasMap } from '../../../../utils/get-column-path.js';
+export type ColumnSortRecord = {
+    order: 'asc' | 'desc';
+    column: string;
+};
+export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, sort: string[], aggregate: Aggregate | null | undefined, collection: string, aliasMap: AliasMap, returnRecords?: boolean): {
+    sortRecords: {
+        order: "asc" | "desc";
+        column: any;
+    }[];
+    hasJoins: boolean;
+    hasMultiRelationalSort: boolean;
+} | {
+    hasJoins: boolean;
+    hasMultiRelationalSort: boolean;
+    sortRecords?: never;
+};

package/dist/database/run-ast/lib/apply-query/sort.js

@@ -0,0 +1,87 @@
+import { getColumnPath } from '../../../../utils/get-column-path.js';
+import { getColumn } from '../../utils/get-column.js';
+import { getRelationInfo } from '../../../../utils/get-relation-info.js';
+import { addJoin } from './add-join.js';
+export function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMap, returnRecords = false) {
+    const relations = schema.relations;
+    let hasJoins = false;
+    let hasMultiRelationalSort = false;
+    const sortRecords = sort.map((sortField) => {
+        const column = sortField.split('.');
+        let order = 'asc';
+        if (sortField.startsWith('-')) {
+            order = 'desc';
+        }
+        if (column[0].startsWith('-')) {
+            column[0] = column[0].substring(1);
+        }
+        // Is the column name one of the aggregate functions used in the query if there is any?
+        if (Object.keys(aggregate ?? {}).includes(column[0])) {
+            // If so, return the column name without the order prefix
+            const operation = column[0];
+            // Get the field for the aggregate function
+            const field = column[1];
+            // If the operation is countAll there is no field.
+            if (operation === 'countAll') {
+                return {
+                    order,
+                    column: 'countAll',
+                };
+            }
+            // If the operation is a root count there is no field.
+            if (operation === 'count' && (field === '*' || !field)) {
+                return {
+                    order,
+                    column: 'count',
+                };
+            }
+            // Return the column name with the operation and field name
+            return {
+                order,
+                column: returnRecords ? column[0] : `${operation}->${field}`,
+            };
+        }
+        if (column.length === 1) {
+            const pathRoot = column[0].split(':')[0];
+            const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);
+            if (!relation || ['m2o', 'a2o'].includes(relationType ?? '')) {
+                return {
+                    order,
+                    column: returnRecords ? column[0] : getColumn(knex, collection, column[0], false, schema),
+                };
+            }
+        }
+        const { hasMultiRelational, isJoinAdded } = addJoin({
+            path: column,
+            collection,
+            aliasMap,
+            rootQuery,
+            schema,
+            knex,
+        });
+        const { columnPath } = getColumnPath({
+            path: column,
+            collection,
+            aliasMap,
+            relations,
+            schema,
+        });
+        const [alias, field] = columnPath.split('.');
+        if (!hasJoins) {
+            hasJoins = isJoinAdded;
+        }
+        if (!hasMultiRelationalSort) {
+            hasMultiRelationalSort = hasMultiRelational;
+        }
+        return {
+            order,
+            column: returnRecords ? columnPath : getColumn(knex, alias, field, false, schema),
+        };
+    });
+    if (returnRecords)
+        return { sortRecords, hasJoins, hasMultiRelationalSort };
+    // Clears the order if any, eg: from MSSQL offset
+    rootQuery.clear('order');
+    rootQuery.orderBy(sortRecords);
+    return { hasJoins, hasMultiRelationalSort };
+}

package/dist/database/run-ast/lib/get-db-query.js

@@ -1,14 +1,16 @@
 import { useEnv } from '@directus/env';
 import { cloneDeep } from 'lodash-es';
-import applyQuery, { applyLimit, applySort, generateAlias } from '../../../utils/apply-query.js';
+import { applySort } from './apply-query/sort.js';
 import { getCollectionFromAlias } from '../../../utils/get-collection-from-alias.js';
-import { getColumn } from '../../../utils/get-column.js';
+import { getColumn } from '../utils/get-column.js';
 import { getHelpers } from '../../helpers/index.js';
 import { applyCaseWhen } from '../utils/apply-case-when.js';
 import { getColumnPreprocessor } from '../utils/get-column-pre-processor.js';
 import { getNodeAlias } from '../utils/get-field-alias.js';
 import { getInnerQueryColumnPreProcessor } from '../utils/get-inner-query-column-pre-processor.js';
 import { withPreprocessBindings } from '../utils/with-preprocess-bindings.js';
+import applyQuery, { generateAlias } from './apply-query/index.js';
+import { applyLimit } from './apply-query/pagination.js';
 export function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, permissionsOnly }, { knex, schema }) {
     const aliasMap = Object.create(null);
     const env = useEnv();
@@ -46,12 +48,12 @@ export function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissi
         return dbQuery;
     }
     const primaryKey = schema.collections[table].primary;
-    let dbQuery = knex.from(table);
+    const dbQuery = knex.from(table);
     let sortRecords;
     const innerQuerySortRecords = [];
     let hasMultiRelationalSort;
     if (queryCopy.sort) {
-        const sortResult = applySort(knex, schema, dbQuery, queryCopy, table, aliasMap, true);
+        const sortResult = applySort(knex, schema, dbQuery, queryCopy.sort, queryCopy.aggregate, table, aliasMap, true);
         if (sortResult) {
             sortRecords = sortResult.sortRecords;
             hasMultiRelationalSort = sortResult.hasMultiRelationalSort;
@@ -115,7 +117,7 @@ export function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissi
                 innerQuerySortRecords.push({ alias: sortAlias, order: sortRecord.order, column: orderByColumn });
             });
             if (hasMultiRelationalSort) {
-                dbQuery = helpers.schema.applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields);
+                dbQuery.rowNumber(knex.ref('directus_row_number').toQuery(), knex.raw(`partition by ?? order by ${orderByString}`, [`${table}.${primaryKey}`, ...orderByFields]));
                 // Start order by with directus_row_number. The directus_row_number is derived from a window function that
                 // is ordered by the sort fields within every primary key partition. That ensures that the result with the
                 // row number = 1 is the top-most row of every partition, according to the selected sort fields.

package/dist/database/run-ast/run-ast.js

@@ -49,7 +49,7 @@ export async function runAst(originalAST, schema, accountability, options) {
             return null;
         // Run the items through the special transforms
         const payloadService = new PayloadService(collection, { knex, schema });
-        let items = await payloadService.processValues('read', rawItems, query.alias ?? {});
+        let items = await payloadService.processValues('read', rawItems, query.alias ?? {}, query.aggregate ?? {});
         if (!items || (Array.isArray(items) && items.length === 0))
             return items;
         // Apply the `_in` filters to the nested collection batches

package/dist/database/run-ast/utils/apply-case-when.js

@@ -1,4 +1,4 @@
-import { applyFilter } from '../../../utils/apply-query.js';
+import { applyFilter } from '../lib/apply-query/filter/index.js';
 export function applyCaseWhen({ columnCases, table, aliasMap, cases, column, alias, permissions }, { knex, schema }) {
     const caseQuery = knex.queryBuilder();
     applyFilter(knex, schema, caseQuery, { _or: columnCases }, table, aliasMap, cases, permissions);

package/dist/database/run-ast/utils/get-column-pre-processor.js

@@ -1,5 +1,5 @@
-import { joinFilterWithCases } from '../../../utils/apply-query.js';
-import { getColumn } from '../../../utils/get-column.js';
+import { joinFilterWithCases } from '../lib/apply-query/join-filter-with-cases.js';
+import { getColumn } from './get-column.js';
 import { parseFilterKey } from '../../../utils/parse-filter-key.js';
 import { getHelpers } from '../../helpers/index.js';
 import { applyCaseWhen } from './apply-case-when.js';

package/dist/{utils → database/run-ast/utils}/get-column.js

@@ -1,6 +1,6 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
 import { getFunctionsForType } from '@directus/utils';
-import { getFunctions } from '../database/helpers/index.js';
+import { getFunctions } from '../../helpers/index.js';
 import { InvalidQueryError } from '@directus/errors';
 import { applyFunctionToColumnName } from './apply-function-to-column-name.js';
 /**

package/dist/database/run-ast/utils/get-field-alias.js

@@ -1,4 +1,4 @@
-import { applyFunctionToColumnName } from '../../../utils/apply-function-to-column-name.js';
+import { applyFunctionToColumnName } from './apply-function-to-column-name.js';
 export function getNodeAlias(node) {
     return applyFunctionToColumnName(node.fieldKey);
 }

package/dist/database/run-ast/utils/remove-temporary-fields.js

@@ -1,6 +1,6 @@
 import { toArray } from '@directus/utils';
 import { cloneDeep, pick } from 'lodash-es';
-import { applyFunctionToColumnName } from '../../../utils/apply-function-to-column-name.js';
+import { applyFunctionToColumnName } from './apply-function-to-column-name.js';
 export function removeTemporaryFields(schema, rawItem, ast, primaryKeyField, parentItem) {
     const rawItems = cloneDeep(toArray(rawItem));
     const items = [];

package/dist/database/seeds/01-collections.yaml

@@ -3,7 +3,7 @@ table: directus_collections
 columns:
   collection:
     type: string
-    length: 64
+    length: 'MAX_TABLE_NAME_LENGTH'
     primary: true
     nullable: false
   icon:
@@ -39,4 +39,4 @@ columns:
     length: 255
   sort_field:
     type: string
-    length: 64
+    length: 'MAX_COLUMN_NAME_LENGTH'

package/dist/database/seeds/04-fields.yaml

@@ -5,14 +5,14 @@ columns:
     increments: true
   collection:
     type: string
-    length: 64
+    length: 'MAX_TABLE_NAME_LENGTH'
     nullable: false
     references:
       table: directus_collections
       column: collection
   field:
     type: string
-    length: 64
+    length: 'MAX_COLUMN_NAME_LENGTH'
     nullable: false
   special:
     type: string

package/dist/database/seeds/05-activity.yaml

@@ -22,7 +22,7 @@ columns:
     length: 255
   collection:
     type: string
-    length: 64
+    length: 'MAX_TABLE_NAME_LENGTH'
     nullable: false
     references:
       table: directus_collections

package/dist/database/seeds/08-permissions.yaml

@@ -10,7 +10,7 @@ columns:
       column: id
   collection:
     type: string
-    length: 64
+    length: 'MAX_TABLE_NAME_LENGTH'
     nullable: false
     references:
       table: directus_collections

package/dist/database/seeds/09-presets.yaml

@@ -18,7 +18,7 @@ columns:
       column: id
   collection:
     type: string
-    length: 64
+    length: 'MAX_TABLE_NAME_LENGTH'
     references:
       table: directus_collections
       column: collection

package/dist/database/seeds/10-relations.yaml

@@ -5,36 +5,36 @@ columns:
     increments: true
   many_collection:
     type: string
-    length: 64
+    length: 'MAX_TABLE_NAME_LENGTH'
     nullable: false
     references:
       table: directus_collections
       column: collection
   many_field:
     type: string
-    length: 64
+    length: 'MAX_COLUMN_NAME_LENGTH'
     nullable: false
   many_primary:
     type: string
-    length: 64
+    length: 'MAX_COLUMN_NAME_LENGTH'
     nullable: false
   one_collection:
     type: string
-    length: 64
+    length: 'MAX_TABLE_NAME_LENGTH'
     references:
       table: directus_collections
       column: collection
   one_field:
     type: string
-    length: 64
+    length: 'MAX_COLUMN_NAME_LENGTH'
   one_primary:
     type: string
-    length: 64
+    length: 'MAX_COLUMN_NAME_LENGTH'
   one_collection_field:
     type: string
-    length: 64
+    length: 'MAX_COLUMN_NAME_LENGTH'
   one_allowed_collections:
     type: text
   junction_field:
     type: string
-    length: 64
+    length: 'MAX_COLUMN_NAME_LENGTH'

package/dist/database/seeds/11-revisions.yaml

@@ -12,7 +12,7 @@ columns:
       column: id
   collection:
     type: string
-    length: 64
+    length: 'MAX_TABLE_NAME_LENGTH'
     nullable: false
     references:
       table: directus_collections

package/dist/database/seeds/run.js

@@ -24,7 +24,14 @@ export default async function runSeed(database) {
                 if (columnInfo.type === 'alias' || columnInfo.type === 'unknown')
                     return;
                 if (columnInfo.type === 'string') {
-                    column = tableBuilder.string(columnName, columnInfo.length);
+                    let length = columnInfo.length;
+                    if (length === 'MAX_TABLE_NAME_LENGTH') {
+                        length = helpers.schema.getTableNameMaxLength();
+                    }
+                    else if (length === 'MAX_COLUMN_NAME_LENGTH') {
+                        length = helpers.schema.getColumnNameMaxLength();
+                    }
+                    column = tableBuilder.string(columnName, Number(length));
                 }
                 else if (columnInfo.increments) {
                     column = tableBuilder.increments();

package/dist/flows.js

@@ -297,6 +297,12 @@ class FlowManager {
                 });
             }
         }
+        if ((flow.trigger === 'manual' || flow.trigger === 'webhook') &&
+            flow.options['async'] !== true &&
+            flow.options['error_on_reject'] === true &&
+            lastOperationStatus === 'reject') {
+            throw keyedData[LAST_KEY];
+        }
         if (flow.trigger === 'event' && flow.options['type'] === 'filter' && lastOperationStatus === 'reject') {
             throw keyedData[LAST_KEY];
         }
@@ -315,8 +321,9 @@ class FlowManager {
             return { successor: null, status: 'unknown', data: null, options: null };
         }
         const handler = this.operations.get(operation.type);
-        const options = applyOptionsData(operation.options, keyedData);
+        let options = operation.options;
         try {
+            options = applyOptionsData(options, keyedData);
             let result = await handler(options, {
                 services,
                 env: useEnv(),

package/dist/metrics/lib/create-metrics.js

@@ -7,6 +7,7 @@ import pm2 from 'pm2';
 import { AggregatorRegistry, Counter, Histogram, register } from 'prom-client';
 import { getCache } from '../../cache.js';
 import { hasDatabaseConnection } from '../../database/index.js';
+import { useLogger } from '../../logger/index.js';
 import { redisConfigAvailable, useRedis } from '../../redis/index.js';
 import { getStorage } from '../../storage/index.js';
 const isPM2 = 'PM2_HOME' in process.env;
@@ -15,6 +16,7 @@ const listApps = promisify(pm2.list.bind(pm2));
 const sendDataToProcessId = promisify(pm2.sendDataToProcessId.bind(pm2));
 export function createMetrics() {
     const env = useEnv();
+    const logger = useLogger();
     const services = env['METRICS_SERVICES'] ?? [];
     const aggregates = new Map();
     /**
@@ -54,8 +56,8 @@ export function createMetrics() {
                 }
                 await Promise.allSettled(syncs);
             }
-            catch {
-                // ignore
+            catch (error) {
+                logger.error(error);
             }
         }
     }
@@ -215,11 +217,15 @@ export function createMetrics() {
             try {
                 await disk.write(`metric-${checkId}`, Readable.from(['check']));
                 const fileStream = await disk.read(`metric-${checkId}`);
-                await new Promise((resolve) => fileStream.on('data', async () => {
-                    fileStream.destroy();
-                    await disk.delete(`metric-${checkId}`);
-                    return resolve(null);
-                }));
+                fileStream.on('data', async () => {
+                    try {
+                        fileStream.destroy();
+                        await disk.delete(`metric-${checkId}`);
+                    }
+                    catch (error) {
+                        logger.error(error);
+                    }
+                });
             }
             catch {
                 metric.inc();

package/dist/operations/condition/index.js

@@ -1,12 +1,15 @@
 import { defineOperationApi } from '@directus/extensions';
-import { validatePayload } from '@directus/utils';
+import { parseFilter, validatePayload } from '@directus/utils';
 import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 export default defineOperationApi({
     id: 'condition',
-    handler: ({ filter }, { data }) => {
-        const errors = validatePayload(filter, data, { requireAll: true });
+    handler: ({ filter }, { data, accountability }) => {
+        const parsedFilter = parseFilter(filter, accountability);
+        if (!parsedFilter) {
+            return null;
+        }
+        const errors = validatePayload(parsedFilter, data, { requireAll: true });
         if (errors.length > 0) {
-            // sanitize and format errors
             const validationErrors = errors
                 .map((error) => error.details.map((details) => new FailedValidationError(joiValidationErrorItemToErrorExtensions(details))))
                 .flat();

package/dist/operations/exec/index.js

@@ -1,5 +1,6 @@
 import { defineOperationApi } from '@directus/extensions';
 import { createRequire } from 'node:module';
+import { sieveFunctions } from '@directus/utils';
 const require = createRequire(import.meta.url);
 const ivm = require('isolated-vm');
 /**
@@ -31,7 +32,7 @@ export default defineOperationApi({
         }, { copy: true });
         // Run the operation once to define the module.exports function
         await context.eval(code, { timeout: scriptTimeoutMs });
-        const inputData = new ivm.ExternalCopy({ data });
+        const inputData = new ivm.ExternalCopy({ data: sieveFunctions(data) });
         const resultRef = await context.evalClosure(`return module.exports($0.data)`, [inputData.copyInto()], {
             result: { reference: true, promise: true },
             timeout: scriptTimeoutMs,

package/dist/permissions/utils/default-permission.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFUAULT_PERMISSION: {
+    policy: null;
+    permissions: null;
+    validation: null;
+    presets: null;
+    fields: null;
+};

package/dist/permissions/utils/default-permission.js

@@ -0,0 +1,7 @@
+export const DEFUAULT_PERMISSION = {
+    policy: null,
+    permissions: null,
+    validation: null,
+    presets: null,
+    fields: null,
+};

package/dist/services/collections.js

@@ -70,25 +70,29 @@ export class CollectionsService {
                     if ('fields' in payload && !Array.isArray(payload.fields)) {
                         throw new InvalidPayloadError({ reason: `"fields" must be an array` });
                     }
-                    // Directus heavily relies on the primary key of a collection, so we have to make sure that
-                    // every collection that is created has a primary key. If no primary key field is created
-                    // while making the collection, we default to an auto incremented id named `id`
+                    /**
+                     * Directus heavily relies on the primary key of a collection, so we have to make sure that
+                     * every collection that is created has a primary key. If no primary key field is created
+                     * while making the collection, we default to an auto incremented id named `id`
+                     */
+                    const injectedPrimaryKeyField = {
+                        field: 'id',
+                        type: 'integer',
+                        meta: {
+                            hidden: true,
+                            interface: 'numeric',
+                            readonly: true,
+                        },
+                        schema: {
+                            is_primary_key: true,
+                            has_auto_increment: true,
+                        },
+                    };
                     if (!payload.fields || payload.fields.length === 0) {
-                        payload.fields = [
-                            {
-                                field: 'id',
-                                type: 'integer',
-                                meta: {
-                                    hidden: true,
-                                    interface: 'numeric',
-                                    readonly: true,
-                                },
-                                schema: {
-                                    is_primary_key: true,
-                                    has_auto_increment: true,
-                                },
-                            },
-                        ];
+                        payload.fields = [injectedPrimaryKeyField];
+                    }
+                    else if (!payload.fields.some((f) => f.schema?.is_primary_key === true || f.schema?.has_auto_increment === true)) {
+                        payload.fields = [injectedPrimaryKeyField, ...payload.fields];
                     }
                     // Ensure that every field meta has the field/collection fields filled correctly
                     payload.fields = payload.fields.map((field) => {

package/dist/services/fields.js

@@ -2,7 +2,7 @@ import { DEFAULT_NUMERIC_PRECISION, DEFAULT_NUMERIC_SCALE, KNEX_TYPES, REGEX_BET
 import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
-import { addFieldFlag, toArray } from '@directus/utils';
+import { addFieldFlag, getRelations, toArray } from '@directus/utils';
 import { isEqual, isNil, merge } from 'lodash-es';
 import { clearSystemCache, getCache, getCacheValue, setCacheValue } from '../cache.js';
 import { ALIAS_TYPES, ALLOWED_DB_DEFAULT_FUNCTIONS } from '../constants.js';
@@ -511,10 +511,7 @@ export class FieldsService {
                 });
             }
             await transaction(this.knex, async (trx) => {
-                const relations = this.schema.relations.filter((relation) => {
-                    return ((relation.collection === collection && relation.field === field) ||
-                        (relation.related_collection === collection && relation.meta?.one_field === field));
-                });
+                const relations = getRelations(this.schema.relations, collection, field);
                 const relationsService = new RelationsService({
                     knex: trx,
                     accountability: this.accountability,