@directus/api 33.3.1 → 34.0.0

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

@@ -1,5 +1,5 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
-import { getRelation, getRelationType } from '@directus/utils';
+import { getRelation, getRelationType, parseFilterFunctionPath } from '@directus/utils';
 import { isEmpty } from 'lodash-es';
 import { fetchPermissions } from '../../../permissions/lib/fetch-permissions.js';
 import { fetchPolicies } from '../../../permissions/lib/fetch-policies.js';
@@ -35,13 +35,58 @@ export async function parseFields(options, context) {
                 name = options.query.alias[fieldKey];
             }
         }
-        const isRelational = name.includes('.') ||
-            // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
-            // anything
-            !!context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === name);
+        // Normalize function calls to move relational prefixes outside the function.
+        // e.g., json(m2m.data, color) → m2m.json(data, color)
+        // This allows the standard relational handling below to process the traversal
+        // uniformly for all functions (json, count, year, etc.).
+        name = parseFilterFunctionPath(name);
+        const isFunctionCall = name.includes('(') && name.includes(')');
+        if (isFunctionCall) {
+            const functionName = name.split('(')[0];
+            const columnName = name.match(REGEX_BETWEEN_PARENS)[1];
+            const foundField = context.schema.collections[options.parentCollection].fields[columnName];
+            // Create a FunctionFieldNode for relational count functions (count(related_items))
+            if (functionName === 'count' && foundField && foundField.type === 'alias') {
+                const foundRelation = context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === columnName);
+                if (foundRelation) {
+                    children.push({
+                        type: 'functionField',
+                        name,
+                        fieldKey,
+                        query: {},
+                        relatedCollection: foundRelation.collection,
+                        whenCase: [],
+                        cases: [],
+                    });
+                    continue;
+                }
+            }
+            // Create a FunctionFieldNode for direct (non-relational) json function calls
+            if (functionName === 'json') {
+                children.push({
+                    type: 'functionField',
+                    name,
+                    fieldKey,
+                    query: {},
+                    relatedCollection: options.parentCollection,
+                    whenCase: [],
+                    cases: [],
+                });
+                continue;
+            }
+        }
+        const isRelationalFunctionCall = isFunctionCall && name.includes('.') && name.indexOf('.') < name.indexOf('(');
+        const isRelational = (!isFunctionCall || isRelationalFunctionCall) &&
+            (name.includes('.') ||
+                // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
+                // anything
+                !!context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === name));
         if (isRelational) {
-            // field is relational
-            const parts = fieldKey.split('.');
+            // For normalized function calls, split on the resolved name since
+            // parseFilterFunctionPath may have moved relational segments outside
+            // the function args (e.g., json(m2m.data, color) → m2m.json(data, color)).
+            // For plain fields, split on fieldKey to preserve existing alias behavior.
+            const parts = (isFunctionCall ? name : fieldKey).split('.');
             let rootField = parts[0];
             let collectionScope = null;
             // a2o related collection scoped field selector `fields=sections.section_id:headings.title`
@@ -72,25 +117,6 @@ export async function parseFields(options, context) {
             }
         }
         else {
-            if (name.includes('(') && name.includes(')')) {
-                const columnName = name.match(REGEX_BETWEEN_PARENS)[1];
-                const foundField = context.schema.collections[options.parentCollection].fields[columnName];
-                if (foundField && foundField.type === 'alias') {
-                    const foundRelation = context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === columnName);
-                    if (foundRelation) {
-                        children.push({
-                            type: 'functionField',
-                            name,
-                            fieldKey,
-                            query: {},
-                            relatedCollection: foundRelation.collection,
-                            whenCase: [],
-                            cases: [],
-                        });
-                        continue;
-                    }
-                }
-            }
             if (name.includes(':')) {
                 const [key, scope] = name.split(':');
                 if (key in relationalStructure === false) {

package/dist/database/helpers/date/dialects/oracle.js

@@ -16,6 +16,8 @@ export class DateHelperOracle extends DateHelper {
     }
     fieldFlagForField(fieldType) {
         switch (fieldType) {
+            case 'json':
+                return 'cast-json';
             case 'dateTime':
                 return 'cast-datetime';
             default:

package/dist/database/helpers/date/dialects/sqlite.js

@@ -17,6 +17,8 @@ export class DateHelperSQLite extends DateHelper {
     }
     fieldFlagForField(fieldType) {
         switch (fieldType) {
+            case 'json':
+                return 'cast-json';
             case 'timestamp':
                 return 'cast-timestamp';
             default:

package/dist/database/helpers/date/types.d.ts

@@ -3,5 +3,5 @@ export declare abstract class DateHelper extends DatabaseHelper {
     parse(date: string | Date): string;
     readTimestampString(date: string): string;
     writeTimestamp(date: string): Date;
-    fieldFlagForField(_fieldType: string): string;
+    fieldFlagForField(fieldType: string): string;
 }

package/dist/database/helpers/date/types.js

@@ -14,7 +14,9 @@ export class DateHelper extends DatabaseHelper {
     writeTimestamp(date) {
         return parseISO(date);
     }
-    fieldFlagForField(_fieldType) {
+    fieldFlagForField(fieldType) {
+        if (fieldType === 'json')
+            return 'cast-json';
         return '';
     }
 }

package/dist/database/helpers/fn/dialects/mssql.d.ts

@@ -11,4 +11,5 @@ export declare class FnHelperMSSQL extends FnHelper {
     minute(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     second(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     count(table: string, column: string, options?: FnHelperOptions): Knex.Raw<any>;
+    json(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
 }

package/dist/database/helpers/fn/dialects/mssql.js

@@ -1,3 +1,4 @@
+import { InvalidQueryError } from '@directus/errors';
 import { FnHelper } from '../types.js';
 const parseLocaltime = (columnType) => {
     if (columnType === 'timestamp') {
@@ -41,4 +42,24 @@ export class FnHelperMSSQL extends FnHelper {
         }
         throw new Error(`Couldn't extract type from ${table}.${column}`);
     }
+    json(table, column, options) {
+        const collectionName = options?.originalCollectionName || table;
+        const fieldSchema = this.schema.collections?.[collectionName]?.fields?.[column];
+        if (!fieldSchema || fieldSchema.type !== 'json' || !options?.jsonPath) {
+            throw new InvalidQueryError({ reason: `${collectionName}.${column} is not a JSON field` });
+        }
+        // ".items[0].name" → "$.items[0].name"
+        const jsonPath = '$' + options?.jsonPath;
+        // JSON_VALUE only returns scalar values (returns NULL for objects/arrays)
+        // JSON_QUERY only returns objects/arrays (returns NULL for scalars)
+        // COALESCE handles both cases
+        return this.knex.raw(`COALESCE(JSON_QUERY(??.??, ?), JSON_VALUE(??.??, ?))`, [
+            table,
+            column,
+            jsonPath,
+            table,
+            column,
+            jsonPath,
+        ]);
+    }
 }

package/dist/database/helpers/fn/dialects/mysql.d.ts

@@ -11,4 +11,6 @@ export declare class FnHelperMySQL extends FnHelper {
     minute(table: string, column: string): Knex.Raw;
     second(table: string, column: string): Knex.Raw;
     count(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    json(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
 }
+export declare function convertToMySQLPath(path: string): string;

package/dist/database/helpers/fn/dialects/mysql.js

@@ -1,3 +1,5 @@
+import { InvalidQueryError } from '@directus/errors';
+import { toPath } from 'lodash-es';
 import { FnHelper } from '../types.js';
 export class FnHelperMySQL extends FnHelper {
     year(table, column) {
@@ -35,4 +37,32 @@ export class FnHelperMySQL extends FnHelper {
         }
         throw new Error(`Couldn't extract type from ${table}.${column}`);
     }
+    json(table, column, options) {
+        const collectionName = options?.originalCollectionName || table;
+        const fieldSchema = this.schema.collections?.[collectionName]?.fields?.[column];
+        if (!fieldSchema || fieldSchema.type !== 'json' || !options?.jsonPath) {
+            throw new InvalidQueryError({ reason: `${collectionName}.${column} is not a JSON field` });
+        }
+        // Convert dot notation to MySQL JSON path
+        // ".items[0].name" → "$['items'][0]['name']"
+        const jsonPath = convertToMySQLPath(options.jsonPath);
+        return this.knex.raw(`JSON_UNQUOTE(JSON_EXTRACT(??.??, ?))`, [table, column, jsonPath]);
+    }
+}
+export function convertToMySQLPath(path) {
+    // Use dot notation for object keys (compatible with both MySQL and MariaDB)
+    // ".color" → "$.color"
+    // ".items[0].name" → "$.items[0].name"
+    const parts = toPath(path.startsWith('.') ? path.slice(1) : path);
+    let result = '$';
+    for (const part of parts) {
+        const num = Number(part);
+        if (Number.isInteger(num) && num >= 0 && String(num) === part) {
+            result += `[${part}]`;
+        }
+        else {
+            result += `.${part}`;
+        }
+    }
+    return result;
 }

package/dist/database/helpers/fn/dialects/oracle.d.ts

@@ -11,4 +11,5 @@ export declare class FnHelperOracle extends FnHelper {
     minute(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     second(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     count(table: string, column: string, options?: FnHelperOptions): Knex.Raw<any>;
+    json(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
 }

package/dist/database/helpers/fn/dialects/oracle.js

@@ -1,3 +1,4 @@
+import { InvalidQueryError } from '@directus/errors';
 import { FnHelper } from '../types.js';
 const parseLocaltime = (columnType) => {
     if (columnType === 'timestamp') {
@@ -41,4 +42,24 @@ export class FnHelperOracle extends FnHelper {
         }
         throw new Error(`Couldn't extract type from ${table}.${column}`);
     }
+    json(table, column, options) {
+        const collectionName = options?.originalCollectionName || table;
+        const fieldSchema = this.schema.collections?.[collectionName]?.fields?.[column];
+        if (!fieldSchema || fieldSchema.type !== 'json' || !options?.jsonPath) {
+            throw new InvalidQueryError({ reason: `${collectionName}.${column} is not a JSON field` });
+        }
+        // ".items[0].name" → "$.items[0].name"
+        const jsonPath = '$' + options.jsonPath;
+        // JSON_VALUE only returns scalar values (returns NULL for objects/arrays)
+        // JSON_QUERY only returns objects/arrays (returns NULL for scalars)
+        // COALESCE handles both cases
+        return this.knex.raw(`COALESCE(JSON_QUERY(??.??, ?), JSON_VALUE(??.??, ?))`, [
+            table,
+            column,
+            jsonPath,
+            table,
+            column,
+            jsonPath,
+        ]);
+    }
 }

package/dist/database/helpers/fn/dialects/postgres.d.ts

@@ -11,4 +11,18 @@ export declare class FnHelperPostgres extends FnHelper {
     minute(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     second(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     count(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    parseJsonResult(value: unknown): unknown;
+    json(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
 }
+/**
+ * Build a parameterized PostgreSQL JSON path using -> operators.
+ * Returns a template string containing only operators and ? placeholders,
+ * plus a bindings array with the actual values.
+ *
+ * @example ".color" → { template: "->?", bindings: ["color"] }
+ * @example ".items[0].name" → { template: "->?->?->?", bindings: ["items", 0, "name"] }
+ */
+export declare function buildPostgresJsonPath(path: string): {
+    template: string;
+    bindings: (string | number)[];
+};

package/dist/database/helpers/fn/dialects/postgres.js

@@ -1,3 +1,5 @@
+import { InvalidQueryError } from '@directus/errors';
+import { toPath } from 'lodash-es';
 import { FnHelper } from '../types.js';
 const parseLocaltime = (columnType) => {
     if (columnType === 'timestamp') {
@@ -45,4 +47,42 @@ export class FnHelperPostgres extends FnHelper {
         }
         throw new Error(`Couldn't extract type from ${table}.${column}`);
     }
+    // The pg driver automatically deserializes json/jsonb columns, so no string parsing needed.
+    parseJsonResult(value) {
+        return value;
+    }
+    json(table, column, options) {
+        const collectionName = options?.originalCollectionName || table;
+        const fieldSchema = this.schema.collections?.[collectionName]?.fields?.[column];
+        if (!fieldSchema || fieldSchema.type !== 'json' || !options?.jsonPath) {
+            throw new InvalidQueryError({ reason: `${collectionName}.${column} is not a JSON field` });
+        }
+        const { template, bindings } = buildPostgresJsonPath(options.jsonPath);
+        const cast = fieldSchema.dbType === 'jsonb' ? 'jsonb' : 'json';
+        return this.knex.raw(`??::${cast}${template}`, [table + '.' + column, ...bindings]);
+    }
+}
+/**
+ * Build a parameterized PostgreSQL JSON path using -> operators.
+ * Returns a template string containing only operators and ? placeholders,
+ * plus a bindings array with the actual values.
+ *
+ * @example ".color" → { template: "->?", bindings: ["color"] }
+ * @example ".items[0].name" → { template: "->?->?->?", bindings: ["items", 0, "name"] }
+ */
+export function buildPostgresJsonPath(path) {
+    const parts = toPath(path.startsWith('.') ? path.slice(1) : path);
+    let template = '';
+    const bindings = [];
+    for (let i = 0; i < parts.length; i++) {
+        const num = Number(parts[i]);
+        template += '->?';
+        if (!isNaN(num) && num >= 0 && Number.isInteger(num)) {
+            bindings.push(num);
+        }
+        else {
+            bindings.push(parts[i]);
+        }
+    }
+    return { template, bindings };
 }

package/dist/database/helpers/fn/dialects/sqlite.d.ts

@@ -11,4 +11,5 @@ export declare class FnHelperSQLite extends FnHelper {
     minute(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
     second(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
     count(table: string, column: string, options?: FnHelperOptions): Knex.Raw<any>;
+    json(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
 }

package/dist/database/helpers/fn/dialects/sqlite.js

@@ -1,3 +1,4 @@
+import { InvalidQueryError } from '@directus/errors';
 import { FnHelper } from '../types.js';
 const parseLocaltime = (columnType) => {
     if (columnType === 'timestamp') {
@@ -65,4 +66,15 @@ export class FnHelperSQLite extends FnHelper {
         }
         throw new Error(`Couldn't extract type from ${table}.${column}`);
     }
+    json(table, column, options) {
+        const collectionName = options?.originalCollectionName || table;
+        const fieldSchema = this.schema.collections?.[collectionName]?.fields?.[column];
+        if (!fieldSchema || fieldSchema.type !== 'json' || !options?.jsonPath) {
+            throw new InvalidQueryError({ reason: `${collectionName}.${column} is not a JSON field` });
+        }
+        // SQLite uses json_extract with $ path notation
+        // ".data.items[0].name" → "$.items[0].name"
+        const jsonPath = '$' + options.jsonPath;
+        return this.knex.raw(`json_extract(??.??, ?)`, [table, column, jsonPath]);
+    }
 }

package/dist/database/helpers/fn/json/parse-function.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Calculates the depth of a JSON path by counting the number of property accesses and array accesses.
+ * @example .color → 1
+ * @example .settings.theme → 2
+ * @example .items[0].name → 3
+ * @example [0] → 1
+ */
+export declare function calculateJsonPathDepth(path: string): number;
+/**
+ * Parses a json function selection into its field and path components.
+ * Expects relational prefixes to have already been extracted by parseFilterFunctionPath,
+ * so the field should always be a simple column name.
+ * @example json(metadata, color) → { field: 'metadata', path: '.color' }
+ * @example json(data, items[0].name) → { field: 'data', path: '.items[0].name' }
+ */
+export declare function parseJsonFunction(functionString: string): {
+    field: string;
+    path: string;
+};

package/dist/database/helpers/fn/json/parse-function.js

@@ -0,0 +1,66 @@
+import { useEnv } from '@directus/env';
+import { InvalidQueryError } from '@directus/errors';
+const env = useEnv();
+const MAX_JSON_QUERY_DEPTH = Number(env['MAX_JSON_QUERY_DEPTH']);
+/**
+ * Calculates the depth of a JSON path by counting the number of property accesses and array accesses.
+ * @example .color → 1
+ * @example .settings.theme → 2
+ * @example .items[0].name → 3
+ * @example [0] → 1
+ */
+export function calculateJsonPathDepth(path) {
+    let depth = 0;
+    for (let i = 0; i < path.length; i++) {
+        if (path[i] === '.' || path[i] === '[') {
+            depth++;
+        }
+    }
+    return depth;
+}
+/**
+ * Parses a json function selection into its field and path components.
+ * Expects relational prefixes to have already been extracted by parseFilterFunctionPath,
+ * so the field should always be a simple column name.
+ * @example json(metadata, color) → { field: 'metadata', path: '.color' }
+ * @example json(data, items[0].name) → { field: 'data', path: '.items[0].name' }
+ */
+export function parseJsonFunction(functionString) {
+    if (!functionString.startsWith('json(') || !functionString.endsWith(')')) {
+        throw new InvalidQueryError({ reason: 'Invalid json() syntax' });
+    }
+    // Extract content between parentheses
+    const content = functionString.substring('json('.length, functionString.length - 1).trim();
+    if (!content) {
+        throw new InvalidQueryError({ reason: 'Invalid json() syntax' });
+    }
+    // Split on comma to separate field from path
+    const commaIndex = content.indexOf(',');
+    if (commaIndex === -1) {
+        throw new InvalidQueryError({ reason: 'Invalid json() syntax: requires json(field, path) format' });
+    }
+    if (commaIndex === 0) {
+        throw new InvalidQueryError({ reason: 'Invalid json() syntax: missing field name' });
+    }
+    const field = content.substring(0, commaIndex).trim();
+    const pathContent = content.substring(commaIndex + 1).trim();
+    if (!pathContent) {
+        throw new InvalidQueryError({ reason: 'Invalid json() syntax: missing path' });
+    }
+    if (pathContent.includes('[]') || /[*?@$]/.test(pathContent)) {
+        throw new InvalidQueryError({ reason: 'Invalid json() syntax: unsupported path expression' });
+    }
+    // Normalize path to always start with dot or bracket
+    const path = pathContent.startsWith('[') ? pathContent : '.' + pathContent;
+    // Validate JSON path depth
+    const depth = calculateJsonPathDepth(path);
+    if (depth > MAX_JSON_QUERY_DEPTH) {
+        throw new InvalidQueryError({
+            reason: `JSON path depth (${depth}) exceeds allowed maximum of ${MAX_JSON_QUERY_DEPTH}`,
+        });
+    }
+    return {
+        field,
+        path,
+    };
+}

package/dist/database/helpers/fn/types.d.ts

@@ -9,6 +9,7 @@ export type FnHelperOptions = {
         cases: Filter[];
         permissions: Permission[];
     } | undefined;
+    jsonPath: string | undefined;
 };
 export declare abstract class FnHelper extends DatabaseHelper {
     protected schema: SchemaOverview;
@@ -22,5 +23,12 @@ export declare abstract class FnHelper extends DatabaseHelper {
     abstract minute(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
     abstract second(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
     abstract count(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract json(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    /**
+     * Parse a value returned from a json() function query.
+     * Most databases return objects/arrays as stringified JSON — override this to skip parsing
+     * for drivers that already deserialize the result (e.g. the pg driver for PostgreSQL).
+     */
+    parseJsonResult(value: unknown): unknown;
     protected _relationalCount(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
 }

package/dist/database/helpers/fn/types.js

@@ -1,3 +1,4 @@
+import { parseJSON } from '@directus/utils';
 import { applyFilter } from '../../run-ast/lib/apply-query/filter/index.js';
 import { generateRelationalQueryAlias } from '../../run-ast/utils/generate-alias.js';
 import { DatabaseHelper } from '../types.js';
@@ -8,6 +9,24 @@ export class FnHelper extends DatabaseHelper {
         this.schema = schema;
         this.schema = schema;
     }
+    /**
+     * Parse a value returned from a json() function query.
+     * Most databases return objects/arrays as stringified JSON — override this to skip parsing
+     * for drivers that already deserialize the result (e.g. the pg driver for PostgreSQL).
+     */
+    parseJsonResult(value) {
+        if (typeof value !== 'string')
+            return value;
+        try {
+            const parsed = parseJSON(value);
+            if (typeof parsed === 'object' && parsed !== null)
+                return parsed;
+        }
+        catch {
+            // keep original string value (e.g. actual string data in the JSON path)
+        }
+        return value;
+    }
     _relationalCount(table, column, options) {
         const collectionName = options?.originalCollectionName || table;
         const relation = this.schema.relations.find((relation) => relation.related_collection === collectionName && relation?.meta?.one_field === column);

package/dist/database/helpers/schema/dialects/mysql.d.ts

@@ -6,4 +6,5 @@ export declare class SchemaHelperMySQL extends SchemaHelper {
     getDatabaseSize(): Promise<number | null>;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
     createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;
+    parseCollectionName(collection: string): Promise<string>;
 }

package/dist/database/helpers/schema/dialects/mysql.js

@@ -4,6 +4,7 @@ import { toArray } from '@directus/utils';
 import { getDefaultIndexName } from '../../../../utils/get-default-index-name.js';
 import { SchemaHelper } from '../types.js';
 const env = useEnv();
+let lowerCaseTableNames;
 export class SchemaHelperMySQL extends SchemaHelper {
     generateIndexName(type, collection, fields) {
         return getDefaultIndexName(type, collection, fields, { maxLength: 64 });
@@ -92,4 +93,14 @@ export class SchemaHelperMySQL extends SchemaHelper {
         }
         return blockingQuery;
     }
+    async parseCollectionName(collection) {
+        if (lowerCaseTableNames === undefined) {
+            const result = await this.knex.raw('SELECT @@lower_case_table_names AS lctn');
+            lowerCaseTableNames = Number(result[0]?.[0]?.lctn ?? 0);
+        }
+        if (lowerCaseTableNames === 1) {
+            return collection.toLowerCase();
+        }
+        return collection;
+    }
 }

package/dist/database/helpers/schema/types.d.ts

@@ -59,4 +59,5 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
     getColumnNameMaxLength(): number;
     getTableNameMaxLength(): number;
     createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;
+    parseCollectionName(collection: string): Promise<string>;
 }

package/dist/database/helpers/schema/types.js

@@ -148,4 +148,7 @@ export class SchemaHelper extends DatabaseHelper {
         const constraintName = this.generateIndexName(isUnique ? 'unique' : 'index', collection, field);
         return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??)`, [constraintName, collection, field]);
     }
+    async parseCollectionName(collection) {
+        return collection;
+    }
 }

package/dist/database/index.js

@@ -246,11 +246,11 @@ export async function validateMigrations() {
  * These database extensions should be optional, so we don't throw or return any problem states when they don't
  */
 export async function validateDatabaseExtensions() {
+    const logger = useLogger();
     const database = getDatabase();
     const client = getDatabaseClient(database);
     const helpers = getHelpers(database);
     const geometrySupport = await helpers.st.supported();
-    const logger = useLogger();
     if (!geometrySupport) {
         switch (client) {
             case 'postgres':
@@ -261,6 +261,7 @@ export async function validateDatabaseExtensions() {
                 break;
             default:
                 logger.warn(`Geometry type not supported on ${client}`);
+                break;
         }
     }
 }

package/dist/database/migrations/20260211A-add-deployment-webhooks.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/20260211A-add-deployment-webhooks.js

@@ -0,0 +1,37 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_deployments', (table) => {
+        table.json('webhook_ids').nullable();
+        table.string('webhook_secret').nullable();
+        table.timestamp('last_synced_at').nullable();
+    });
+    await knex.schema.alterTable('directus_deployment_projects', (table) => {
+        table.string('url').nullable();
+        table.string('framework').nullable();
+        table.boolean('deployable').notNullable().defaultTo(true);
+    });
+    await knex.schema.alterTable('directus_deployment_runs', (table) => {
+        table.string('status').nullable();
+        table.string('url').nullable();
+        table.timestamp('started_at').nullable();
+        table.timestamp('completed_at').nullable();
+    });
+    await knex('directus_deployment_runs').delete();
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_deployment_runs', (table) => {
+        table.dropColumn('status');
+        table.dropColumn('url');
+        table.dropColumn('started_at');
+        table.dropColumn('completed_at');
+    });
+    await knex.schema.alterTable('directus_deployment_projects', (table) => {
+        table.dropColumn('url');
+        table.dropColumn('framework');
+        table.dropColumn('deployable');
+    });
+    await knex.schema.alterTable('directus_deployments', (table) => {
+        table.dropColumn('webhook_ids');
+        table.dropColumn('webhook_secret');
+        table.dropColumn('last_synced_at');
+    });
+}

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" | "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";
+    type: "string" | "boolean" | "binary" | "time" | "integer" | "unknown" | "date" | "text" | "json" | "float" | "alias" | "uuid" | "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" | "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";
+    type: "string" | "boolean" | "binary" | "time" | "integer" | "unknown" | "date" | "text" | "json" | "float" | "alias" | "uuid" | "dateTime" | "timestamp" | "bigInteger" | "decimal" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon";
     special: string[];
 };