@directus/api 33.0.0 → 33.1.0

package/dist/controllers/deployment.js

@@ -0,0 +1,481 @@
+import { ErrorCode, ForbiddenError, InvalidPathParameterError, InvalidPayloadError, isDirectusError, } from '@directus/errors';
+import { DEPLOYMENT_PROVIDER_TYPES } from '@directus/types';
+import express from 'express';
+import Joi from 'joi';
+import getDatabase from '../database/index.js';
+import { respond } from '../middleware/respond.js';
+import useCollection from '../middleware/use-collection.js';
+import { validateBatch } from '../middleware/validate-batch.js';
+import { DeploymentProjectsService } from '../services/deployment-projects.js';
+import { DeploymentRunsService } from '../services/deployment-runs.js';
+import { DeploymentService } from '../services/deployment.js';
+import { MetaService } from '../services/meta.js';
+import asyncHandler from '../utils/async-handler.js';
+import { transaction } from '../utils/transaction.js';
+const router = express.Router();
+router.use(useCollection('directus_deployments'));
+// Require admin access for all deployment routes
+router.use((_req, _res, next) => {
+    if (_req.accountability && _req.accountability.admin !== true) {
+        throw new ForbiddenError();
+    }
+    return next();
+});
+// Validate provider parameter
+const validateProvider = (provider) => {
+    return DEPLOYMENT_PROVIDER_TYPES.includes(provider);
+};
+// Validation schema for creating/updating deployment
+const deploymentSchema = Joi.object({
+    provider: Joi.string()
+        .valid(...DEPLOYMENT_PROVIDER_TYPES)
+        .required(),
+    credentials: Joi.object().required(),
+    options: Joi.object(),
+}).unknown();
+// Create deployment config
+router.post('/', asyncHandler(async (req, res, next) => {
+    const { error } = deploymentSchema.validate(req.body);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    const db = getDatabase();
+    const item = await transaction(db, async (trx) => {
+        const service = new DeploymentService({
+            accountability: req.accountability,
+            schema: req.schema,
+            knex: trx,
+        });
+        const key = await service.createOne({
+            provider: req.body.provider,
+            credentials: req.body.credentials,
+            options: req.body.options,
+        });
+        return service.readOne(key, req.sanitizedQuery);
+    });
+    res.locals['payload'] = { data: item };
+    return next();
+}), respond);
+// Read all deployment configs
+const readHandler = asyncHandler(async (req, res, next) => {
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const records = await service.readByQuery(req.sanitizedQuery);
+    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+    res.locals['payload'] = { data: records || null, meta };
+    return next();
+});
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+// Read single deployment config by provider
+router.get('/:provider', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const record = await service.readByProvider(provider, req.sanitizedQuery);
+    res.locals['payload'] = { data: record || null };
+    return next();
+}), respond);
+// List projects from provider (for config/selection)
+router.get('/:provider/projects', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const projectsService = new DeploymentProjectsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Get provider config to find deployment ID
+    const deployment = await service.readByProvider(provider);
+    // Get projects from provider (with cache)
+    const { data: providerProjects, remainingTTL } = await service.listProviderProjects(provider);
+    // Get selected projects from DB
+    const selectedProjects = await projectsService.readByQuery({
+        filter: { deployment: { _eq: deployment.id } },
+    });
+    // Map by external_id for quick lookup
+    const selectedMap = new Map(selectedProjects.map((p) => [p.external_id, p]));
+    // Sync names from provider
+    const namesToUpdate = selectedProjects
+        .map((dbProject) => {
+        const providerProject = providerProjects.find((p) => p.id === dbProject.external_id);
+        if (providerProject && providerProject.name !== dbProject.name) {
+            return { id: dbProject.id, name: providerProject.name };
+        }
+        return null;
+    })
+        .filter((update) => update !== null);
+    if (namesToUpdate.length > 0) {
+        await projectsService.updateBatch(namesToUpdate);
+    }
+    // Merge with DB structure (id !== null means selected)
+    const projects = providerProjects.map((project) => {
+        return {
+            id: selectedMap.get(project.id)?.id ?? null,
+            external_id: project.id,
+            name: project.name,
+            deployable: project.deployable,
+            framework: project.framework,
+        };
+    });
+    // Pass remaining TTL for response headers
+    res.locals['cache'] = false;
+    res.locals['cacheTTL'] = remainingTTL;
+    res.locals['payload'] = { data: projects };
+    return next();
+}), respond);
+// Get single project details
+router.get('/:provider/projects/:id', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    const projectId = req.params['id'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const projectsService = new DeploymentProjectsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Get project from DB (validates it exists and is selected)
+    const project = await projectsService.readOne(projectId);
+    // Fetch details from provider using external_id (with cache)
+    const { data: details, remainingTTL } = await service.getProviderProject(provider, project.external_id);
+    // Pass remaining TTL for response headers
+    res.locals['cache'] = false;
+    res.locals['cacheTTL'] = remainingTTL;
+    res.locals['payload'] = {
+        data: {
+            ...details,
+            id: project.id,
+            external_id: project.external_id,
+        },
+    };
+    return next();
+}), respond);
+// Update selected projects
+const updateProjectsSchema = Joi.object({
+    create: Joi.array()
+        .items(Joi.object({
+        external_id: Joi.string().required(),
+        name: Joi.string().required(),
+    }))
+        .default([]),
+    delete: Joi.array().items(Joi.string()).default([]),
+});
+router.patch('/:provider/projects', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const { error, value } = updateProjectsSchema.validate(req.body);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const projectsService = new DeploymentProjectsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Get provider config
+    const deployment = await service.readByProvider(provider);
+    // Validate deployable projects before any mutation
+    if (value.create.length > 0) {
+        const driver = await service.getDriver(provider);
+        const providerProjects = await driver.listProjects();
+        const projectsMap = new Map(providerProjects.map((p) => [p.id, p]));
+        const nonDeployable = value.create.filter((p) => !projectsMap.get(p.external_id)?.deployable);
+        if (nonDeployable.length > 0) {
+            const names = nonDeployable
+                .map((p) => projectsMap.get(p.external_id)?.name || p.external_id)
+                .join(', ');
+            throw new InvalidPayloadError({
+                reason: `Cannot add non-deployable projects: ${names}`,
+            });
+        }
+    }
+    const updatedProjects = await projectsService.updateSelection(deployment.id, value.create, value.delete);
+    res.locals['payload'] = { data: updatedProjects };
+    return next();
+}), respond);
+// Dashboard - selected projects with stats
+router.get('/:provider/dashboard', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const projectsService = new DeploymentProjectsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Get provider config
+    const deployment = await service.readByProvider(provider);
+    // Get selected projects from DB
+    const selectedProjects = await projectsService.readByQuery({
+        filter: { deployment: { _eq: deployment.id } },
+    });
+    if (selectedProjects.length === 0) {
+        res.locals['payload'] = { data: { projects: [] } };
+        return next();
+    }
+    // Fetch full details for each selected project (parallel)
+    const driver = await service.getDriver(provider);
+    const projectDetails = await Promise.all(selectedProjects.map(async (p) => {
+        const details = await driver.getProject(p.external_id);
+        return {
+            ...details,
+            id: p.id,
+            external_id: p.external_id,
+        };
+    }));
+    // Disable cache - dashboard needs fresh data from provider
+    res.locals['cache'] = false;
+    res.locals['payload'] = { data: { projects: projectDetails } };
+    return next();
+}), respond);
+// Trigger deployment for a project
+const triggerDeploySchema = Joi.object({
+    preview: Joi.boolean().default(false),
+    clear_cache: Joi.boolean().default(true), // Default at true (matches Vercel UI behavior)
+});
+router.post('/:provider/projects/:id/deploy', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    const projectId = req.params['id'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const { error, value } = triggerDeploySchema.validate(req.body);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const projectsService = new DeploymentProjectsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const runsService = new DeploymentRunsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Get project from DB
+    const project = await projectsService.readOne(projectId);
+    // Trigger deployment via driver
+    const driver = await service.getDriver(provider);
+    const result = await driver.triggerDeployment(project.external_id, {
+        preview: value.preview,
+        clearCache: value.clear_cache,
+    });
+    // Store run in DB
+    const runId = await runsService.createOne({
+        project: projectId,
+        external_id: result.deployment_id,
+        target: value.preview ? 'preview' : 'production',
+    });
+    const run = await runsService.readOne(runId);
+    res.locals['payload'] = {
+        data: {
+            ...run,
+            status: result.status,
+            url: result.url,
+        },
+    };
+    return next();
+}), respond);
+// Update deployment config by provider
+router.patch('/:provider', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const db = getDatabase();
+    const item = await transaction(db, async (trx) => {
+        const service = new DeploymentService({
+            accountability: req.accountability,
+            schema: req.schema,
+            knex: trx,
+        });
+        const data = {};
+        if ('credentials' in req.body)
+            data['credentials'] = req.body.credentials;
+        if ('options' in req.body)
+            data['options'] = req.body.options;
+        const primaryKey = await service.updateByProvider(provider, data);
+        try {
+            return await service.readOne(primaryKey, req.sanitizedQuery);
+        }
+        catch (error) {
+            if (isDirectusError(error, ErrorCode.Forbidden)) {
+                return null;
+            }
+            throw error;
+        }
+    });
+    res.locals['payload'] = { data: item };
+    return next();
+}), respond);
+// Delete deployment config by provider
+router.delete('/:provider', asyncHandler(async (req, _res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.deleteByProvider(provider);
+    return next();
+}), respond);
+// List runs for a project
+router.get('/:provider/projects/:id/runs', asyncHandler(async (req, res, next) => {
+    // Disable cache - runs status needs to be fresh from provider
+    res.locals['cache'] = false;
+    const provider = req.params['provider'];
+    const projectId = req.params['id'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const projectsService = new DeploymentProjectsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const runsService = new DeploymentRunsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Validate project exists
+    await projectsService.readOne(projectId);
+    // Get paginated runs from DB (default limit: 10)
+    const query = {
+        ...req.sanitizedQuery,
+        filter: { project: { _eq: projectId } },
+        sort: ['-date_created'],
+        limit: req.sanitizedQuery.limit ?? 10,
+        fields: ['*', 'user_created.first_name', 'user_created.last_name', 'user_created.email'],
+    };
+    const runs = await runsService.readByQuery(query);
+    // Get pagination meta
+    const metaService = new MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const meta = await metaService.getMetaForQuery('directus_deployment_runs', query);
+    // Fetch status for each run from provider
+    const driver = await service.getDriver(provider);
+    const runsWithStatus = await Promise.all(runs.map(async (run) => {
+        const details = await driver.getDeployment(run.external_id);
+        return {
+            ...run,
+            ...details,
+            id: run.id,
+            external_id: run.external_id,
+        };
+    }));
+    res.locals['payload'] = { data: runsWithStatus, meta };
+    return next();
+}), respond);
+// Get single run details
+const runDetailsQuerySchema = Joi.object({
+    since: Joi.date().iso().optional(),
+    _t: Joi.number().optional(), // Cache-buster parameter for polling
+});
+router.get('/:provider/runs/:id', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    const runId = req.params['id'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const { error, value } = runDetailsQuerySchema.validate(req.query);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    const sinceDate = value.since;
+    const runsService = new DeploymentRunsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const run = await runsService.readOne(runId);
+    const driver = await service.getDriver(provider);
+    const [details, logs] = await Promise.all([
+        driver.getDeployment(run.external_id),
+        driver.getDeploymentLogs(run.external_id, sinceDate ? { since: sinceDate } : undefined),
+    ]);
+    res.locals['cache'] = false;
+    res.locals['payload'] = {
+        data: {
+            ...run,
+            ...details,
+            id: run.id,
+            external_id: run.external_id,
+            logs,
+        },
+    };
+    return next();
+}), respond);
+// Cancel a deployment
+router.post('/:provider/runs/:id/cancel', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    const runId = req.params['id'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const runsService = new DeploymentRunsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const run = await runsService.readOne(runId);
+    const driver = await service.getDriver(provider);
+    await driver.cancelDeployment(run.external_id);
+    // Fetch updated status
+    const details = await driver.getDeployment(run.external_id);
+    res.locals['payload'] = {
+        data: {
+            ...run,
+            ...details,
+            id: run.id,
+            external_id: run.external_id,
+        },
+    };
+    return next();
+}), respond);
+export default router;

package/dist/controllers/fields.js

@@ -91,8 +91,9 @@ router.patch('/:collection', validateCollection, asyncHandler(async (req, res, n
     for (const fieldData of req.body) {
         if (isSystemField(req.params['collection'], fieldData['field'])) {
             const { error } = systemFieldUpdateSchema.safeParse(fieldData);
-            if (error)
-                throw error.issues.map((details) => new InvalidPayloadError({ reason: details.message }));
+            if (error) {
+                throw new InvalidPayloadError({ reason: 'Only "schema.is_indexed" may be modified for system fields' });
+            }
         }
     }
     await service.updateFields(req.params['collection'], req.body, {
@@ -134,8 +135,9 @@ router.patch('/:collection/:field', validateCollection, asyncHandler(async (req,
     });
     if (isSystemField(req.params['collection'], req.params['field'])) {
         const { error } = systemFieldUpdateSchema.safeParse(req.body);
-        if (error)
-            throw error.issues.map((details) => new InvalidPayloadError({ reason: details.message }));
+        if (error) {
+            throw new InvalidPayloadError({ reason: 'Only "schema.is_indexed" may be modified for system fields' });
+        }
     }
     else {
         const { error } = updateSchema.validate(req.body);

package/dist/database/get-ast-from-query/lib/parse-fields.js

@@ -1,9 +1,8 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
-import { getRelation } from '@directus/utils';
+import { getRelation, getRelationType } from '@directus/utils';
 import { isEmpty } from 'lodash-es';
 import { fetchPermissions } from '../../../permissions/lib/fetch-permissions.js';
 import { fetchPolicies } from '../../../permissions/lib/fetch-policies.js';
-import { getRelationType } from '../../../utils/get-relation-type.js';
 import { getAllowedSort } from '../utils/get-allowed-sort.js';
 import { getDeepQuery } from '../utils/get-deep-query.js';
 import { getRelatedCollection } from '../utils/get-related-collection.js';
@@ -118,6 +117,7 @@ export async function parseFields(options, context) {
             relation,
             collection: options.parentCollection,
             field: fieldName,
+            useA2O: true,
         });
         if (!relationType)
             continue;

package/dist/database/migrations/20260110A-add-ai-provider-settings.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20260110A-add-ai-provider-settings.js

@@ -0,0 +1,35 @@
+const DEFAULT_OPENAI_MODELS = ['gpt-5-nano', 'gpt-5-mini', 'gpt-5'];
+const DEFAULT_ANTHROPIC_MODELS = ['claude-haiku-4-5', 'claude-sonnet-4-5'];
+const DEFAULT_GOOGLE_MODELS = ['gemini-3-pro-preview', 'gemini-3-flash-preview', 'gemini-2.5-pro', 'gemini-2.5-flash'];
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.text('ai_google_api_key');
+        table.text('ai_openai_compatible_api_key');
+        table.text('ai_openai_compatible_base_url');
+        table.text('ai_openai_compatible_name');
+        table.json('ai_openai_compatible_models');
+        table.json('ai_openai_compatible_headers');
+        table.json('ai_openai_allowed_models');
+        table.json('ai_anthropic_allowed_models');
+        table.json('ai_google_allowed_models');
+    });
+    // Set default allowed models for existing installations
+    await knex('directus_settings').update({
+        ai_openai_allowed_models: JSON.stringify(DEFAULT_OPENAI_MODELS),
+        ai_anthropic_allowed_models: JSON.stringify(DEFAULT_ANTHROPIC_MODELS),
+        ai_google_allowed_models: JSON.stringify(DEFAULT_GOOGLE_MODELS),
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('ai_google_api_key');
+        table.dropColumn('ai_openai_compatible_api_key');
+        table.dropColumn('ai_openai_compatible_base_url');
+        table.dropColumn('ai_openai_compatible_name');
+        table.dropColumn('ai_openai_compatible_models');
+        table.dropColumn('ai_openai_compatible_headers');
+        table.dropColumn('ai_openai_allowed_models');
+        table.dropColumn('ai_anthropic_allowed_models');
+        table.dropColumn('ai_google_allowed_models');
+    });
+}

package/dist/database/migrations/20260128A-add-collaborative-editing.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20260128A-add-collaborative-editing.js

@@ -0,0 +1,10 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.boolean('collaborative_editing_enabled').defaultTo(false).notNullable();
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('collaborative_editing_enabled');
+    });
+}

package/dist/database/migrations/20260204A-add-deployment.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20260204A-add-deployment.js

@@ -0,0 +1,32 @@
+export async function up(knex) {
+    await knex.schema.createTable('directus_deployments', (table) => {
+        table.uuid('id').primary().notNullable();
+        table.string('provider').notNullable().unique();
+        table.text('credentials');
+        table.text('options');
+        table.timestamp('date_created').defaultTo(knex.fn.now());
+        table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
+    });
+    await knex.schema.createTable('directus_deployment_projects', (table) => {
+        table.uuid('id').primary().notNullable();
+        table.uuid('deployment').notNullable().references('id').inTable('directus_deployments').onDelete('CASCADE');
+        table.string('external_id').notNullable();
+        table.string('name').notNullable();
+        table.timestamp('date_created').defaultTo(knex.fn.now());
+        table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
+        table.unique(['deployment', 'external_id']);
+    });
+    await knex.schema.createTable('directus_deployment_runs', (table) => {
+        table.uuid('id').primary().notNullable();
+        table.uuid('project').notNullable().references('id').inTable('directus_deployment_projects').onDelete('CASCADE');
+        table.string('external_id').notNullable();
+        table.string('target').notNullable(); // 'production' or 'preview'
+        table.timestamp('date_created').defaultTo(knex.fn.now());
+        table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
+    });
+}
+export async function down(knex) {
+    await knex.schema.dropTable('directus_deployment_runs');
+    await knex.schema.dropTable('directus_deployment_projects');
+    await knex.schema.dropTable('directus_deployments');
+}

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

@@ -1,6 +1,6 @@
 import { InvalidQueryError } from '@directus/errors';
+import { getRelationInfo } from '@directus/utils';
 import { clone } from 'lodash-es';
-import { getRelationInfo } from '../../../../utils/get-relation-info.js';
 import { getHelpers } from '../../../helpers/index.js';
 import { generateJoinAlias } from '../../utils/generate-alias.js';
 export function addJoin({ path, collection, aliasMap, rootQuery, schema, knex }) {

package/dist/database/run-ast/lib/apply-query/filter/get-filter-type.d.ts

@@ -1,8 +1,8 @@
 import type { FieldOverview } from '@directus/types';
 export declare function getFilterType(fields: Record<string, FieldOverview>, key: string, collection?: string): {
-    type: "string" | "boolean" | "binary" | "text" | "unknown" | "integer" | "date" | "float" | "alias" | "uuid" | "time" | "dateTime" | "timestamp" | "bigInteger" | "decimal" | "json" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon";
+    type: "string" | "boolean" | "binary" | "integer" | "unknown" | "date" | "text" | "json" | "float" | "alias" | "uuid" | "time" | "dateTime" | "timestamp" | "bigInteger" | "decimal" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon";
     special?: never;
 } | {
-    type: "string" | "boolean" | "binary" | "text" | "unknown" | "integer" | "date" | "float" | "alias" | "uuid" | "time" | "dateTime" | "timestamp" | "bigInteger" | "decimal" | "json" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon";
+    type: "string" | "boolean" | "binary" | "integer" | "unknown" | "date" | "text" | "json" | "float" | "alias" | "uuid" | "time" | "dateTime" | "timestamp" | "bigInteger" | "decimal" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon";
     special: string[];
 };

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

@@ -1,7 +1,7 @@
 import { InvalidQueryError } from '@directus/errors';
+import { getRelationInfo } from '@directus/utils';
 import { getCases } from '../../../../../permissions/modules/process-ast/lib/get-cases.js';
 import { getColumnPath } from '../../../../../utils/get-column-path.js';
-import { getRelationInfo } from '../../../../../utils/get-relation-info.js';
 import { getHelpers } from '../../../../helpers/index.js';
 import { addJoin } from '../add-join.js';
 import { getFilterPath } from '../get-filter-path.js';

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

@@ -1,5 +1,5 @@
+import { getRelationInfo } from '@directus/utils';
 import { getColumnPath } from '../../../../utils/get-column-path.js';
-import { getRelationInfo } from '../../../../utils/get-relation-info.js';
 import { getColumn } from '../../utils/get-column.js';
 import { addJoin } from './add-join.js';
 export function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMap, returnRecords = false) {