@directus/api 23.3.2 → 24.0.1

package/dist/constants.d.ts

@@ -18,8 +18,8 @@ export declare const SUPPORTED_IMAGE_METADATA_FORMATS: string[];
 /** Resumable uploads */
 export declare const RESUMABLE_UPLOADS: {
     ENABLED: boolean;
-    CHUNK_SIZE: number;
-    MAX_SIZE: number;
+    CHUNK_SIZE: number | null;
+    MAX_SIZE: number | null;
     EXPIRATION_TIME: number;
     SCHEDULE: string;
 };

package/dist/controllers/files.js

@@ -35,7 +35,7 @@ export const multipartHandler = (req, res, next) => {
         headers,
         defParamCharset: 'utf8',
         limits: {
-            fileSize: env['FILES_MAX_UPLOAD_SIZE'] ? bytes.parse(env['FILES_MAX_UPLOAD_SIZE']) : undefined,
+            fileSize: bytes.parse(env['FILES_MAX_UPLOAD_SIZE']) ?? undefined,
         },
     });
     const savedFiles = [];

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

@@ -169,10 +169,11 @@ export async function parseFields(options, context) {
                     continue;
                 }
             }
+            const childQuery = { ...options.query };
             // update query alias for children parseFields
             const deepAlias = getDeepQuery(options.deep?.[fieldKey] || {})?.['alias'];
-            if (!isEmpty(deepAlias))
-                options.query.alias = deepAlias;
+            // reset alias to empty if none are present
+            childQuery.alias = isEmpty(deepAlias) ? {} : deepAlias;
             child = {
                 type: relationType,
                 name: relatedCollection,
@@ -184,7 +185,7 @@ export async function parseFields(options, context) {
                 children: await parseFields({
                     parentCollection: relatedCollection,
                     fields: nestedFields,
-                    query: options.query,
+                    query: childQuery,
                     deep: options.deep?.[fieldKey] || {},
                     accountability: options.accountability,
                 }, context),

package/dist/database/helpers/index.d.ts

@@ -3,17 +3,15 @@ import type { Knex } from 'knex';
 import * as dateHelpers from './date/index.js';
 import * as fnHelpers from './fn/index.js';
 import * as geometryHelpers from './geometry/index.js';
+import * as numberHelpers from './number/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
-import * as numberHelpers from './number/index.js';
-import * as nullableUpdateHelper from './nullable-update/index.js';
 export declare function getHelpers(database: Knex): {
     date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.mysql | dateHelpers.mssql | dateHelpers.sqlite;
     st: geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.mysql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
     schema: schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.mysql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle | schemaHelpers.redshift;
     sequence: sequenceHelpers.mysql | sequenceHelpers.postgres;
     number: numberHelpers.cockroachdb | numberHelpers.mssql | numberHelpers.postgres | numberHelpers.sqlite | numberHelpers.oracle;
-    nullableUpdate: nullableUpdateHelper.postgres | nullableUpdateHelper.oracle;
 };
 export declare function getFunctions(database: Knex, schema: SchemaOverview): fnHelpers.postgres | fnHelpers.mssql | fnHelpers.mysql | fnHelpers.sqlite | fnHelpers.oracle;
 export type Helpers = ReturnType<typeof getHelpers>;

package/dist/database/helpers/index.js

@@ -2,10 +2,9 @@ import { getDatabaseClient } from '../index.js';
 import * as dateHelpers from './date/index.js';
 import * as fnHelpers from './fn/index.js';
 import * as geometryHelpers from './geometry/index.js';
+import * as numberHelpers from './number/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
-import * as numberHelpers from './number/index.js';
-import * as nullableUpdateHelper from './nullable-update/index.js';
 export function getHelpers(database) {
     const client = getDatabaseClient(database);
     return {
@@ -14,7 +13,6 @@ export function getHelpers(database) {
         schema: new schemaHelpers[client](database),
         sequence: new sequenceHelpers[client](database),
         number: new numberHelpers[client](database),
-        nullableUpdate: new nullableUpdateHelper[client](database),
     };
 }
 export function getFunctions(database, schema) {

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

@@ -1,6 +1,7 @@
 import type { Knex } from 'knex';
 import { SchemaHelper, type SortRecord, type Sql } from '../types.js';
 export declare class SchemaHelperMSSQL extends SchemaHelper {
+    generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
     applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
     formatUUID(uuid: string): string;

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

@@ -1,6 +1,10 @@
+import { getDefaultIndexName } from '../../../../utils/get-default-index-name.js';
 import { SchemaHelper } from '../types.js';
 import { prepQueryParams } from '../utils/prep-query-params.js';
 export class SchemaHelperMSSQL extends SchemaHelper {
+    generateIndexName(type, collection, fields) {
+        return getDefaultIndexName(type, collection, fields, { maxLength: 128 });
+    }
     applyLimit(rootQuery, limit) {
         // The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries,
         // and common table expressions, unless TOP, OFFSET or FOR XML is also specified.

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

@@ -1,6 +1,7 @@
 import type { Knex } from 'knex';
 import { SchemaHelper, type SortRecord } from '../types.js';
 export declare class SchemaHelperMySQL extends SchemaHelper {
+    generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
     getDatabaseSize(): Promise<number | null>;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;

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

@@ -1,8 +1,12 @@
 import { useEnv } from '@directus/env';
+import { getDefaultIndexName } from '../../../../utils/get-default-index-name.js';
 import { getDatabaseVersion } from '../../../index.js';
 import { SchemaHelper } from '../types.js';
 const env = useEnv();
 export class SchemaHelperMySQL extends SchemaHelper {
+    generateIndexName(type, collection, fields) {
+        return getDefaultIndexName(type, collection, fields, { maxLength: 64 });
+    }
     applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {
         if (getDatabaseVersion()?.startsWith('5.7')) {
             dbQuery.orderByRaw(`?? asc, ${orderByString}`, [`${table}.${primaryKey}`, ...orderByFields]);

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

@@ -1,14 +1,20 @@
 import type { KNEX_TYPES } from '@directus/constants';
-import type { Field, Relation, Type } from '@directus/types';
+import type { Column } from '@directus/schema';
+import type { Field, RawField, Relation, Type } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Options, SortRecord, Sql } from '../types.js';
 import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperOracle extends SchemaHelper {
+    generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
     castA2oPrimaryKey(): string;
     preRelationChange(relation: Partial<Relation>): void;
     processFieldType(field: Field): Type;
     getDatabaseSize(): Promise<number | null>;
+    /**
+     * Oracle throws an error when overwriting the nullable option for an existing column with the same value.
+     */
+    setNullable(column: Knex.ColumnBuilder, field: RawField | Field, existing: Column | null): void;
     prepQueryParams(queryParams: Sql): Sql;
     prepBindings(bindings: Knex.Value[]): any;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;

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

@@ -1,6 +1,19 @@
+import crypto from 'node:crypto';
+import { getDefaultIndexName } from '../../../../utils/get-default-index-name.js';
 import { SchemaHelper } from '../types.js';
 import { prepQueryParams } from '../utils/prep-query-params.js';
 export class SchemaHelperOracle extends SchemaHelper {
+    generateIndexName(type, collection, fields) {
+        // Backwards compatibility with oracle requires no hash added to the name.
+        let indexName = getDefaultIndexName(type, collection, fields, { maxLength: Infinity });
+        // Knex generates a hash of the name if it is above the allowed value
+        // https://github.com/knex/knex/blob/master/lib/dialects/oracle/utils.js#L20
+        if (indexName.length > 128) {
+            // generates the sha1 of the name and encode it with base64
+            indexName = crypto.createHash('sha1').update(indexName).digest('base64').replace('=', '');
+        }
+        return indexName;
+    }
     async changeToType(table, column, type, options = {}) {
         await this.changeToTypeByCopy(table, column, type, options);
     }
@@ -39,6 +52,21 @@ export class SchemaHelperOracle extends SchemaHelper {
             return null;
         }
     }
+    /**
+     * Oracle throws an error when overwriting the nullable option for an existing column with the same value.
+     */
+    setNullable(column, field, existing) {
+        if (!existing) {
+            super.setNullable(column, field, existing);
+            return;
+        }
+        if (field.schema?.is_nullable === false && existing.is_nullable === true) {
+            column.notNullable();
+        }
+        else if (field.schema?.is_nullable === true && existing.is_nullable === false) {
+            column.nullable();
+        }
+    }
     prepQueryParams(queryParams) {
         return prepQueryParams(queryParams, { format: (index) => `:${index + 1}` });
     }

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

@@ -1,6 +1,7 @@
 import type { Knex } from 'knex';
 import { SchemaHelper, type SortRecord, type Sql } from '../types.js';
 export declare class SchemaHelperPostgres extends SchemaHelper {
+    generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     getDatabaseSize(): Promise<number | null>;
     prepQueryParams(queryParams: Sql): Sql;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;

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

@@ -1,8 +1,12 @@
 import { useEnv } from '@directus/env';
+import { getDefaultIndexName } from '../../../../utils/get-default-index-name.js';
 import { SchemaHelper } from '../types.js';
 import { prepQueryParams } from '../utils/prep-query-params.js';
 const env = useEnv();
 export class SchemaHelperPostgres extends SchemaHelper {
+    generateIndexName(type, collection, fields) {
+        return getDefaultIndexName(type, collection, fields, { maxLength: 63 });
+    }
     async getDatabaseSize() {
         try {
             const result = await this.knex.select(this.knex.raw(`pg_database_size(?) as size;`, [env['DB_DATABASE']]));

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

@@ -1,5 +1,6 @@
 import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperSQLite extends SchemaHelper {
+    generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     preColumnChange(): Promise<boolean>;
     postColumnChange(): Promise<void>;
     getDatabaseSize(): Promise<number | null>;

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

@@ -1,5 +1,9 @@
+import { getDefaultIndexName } from '../../../../utils/get-default-index-name.js';
 import { SchemaHelper } from '../types.js';
 export class SchemaHelperSQLite extends SchemaHelper {
+    generateIndexName(type, collection, fields) {
+        return getDefaultIndexName(type, collection, fields, { maxLength: Infinity });
+    }
     async preColumnChange() {
         const foreignCheckStatus = (await this.knex.raw('PRAGMA foreign_keys'))[0].foreign_keys === 1;
         if (foreignCheckStatus) {

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

@@ -1,5 +1,6 @@
 import type { KNEX_TYPES } from '@directus/constants';
-import type { Field, Relation, Type } from '@directus/types';
+import type { Column } from '@directus/schema';
+import type { Field, RawField, Relation, Type } from '@directus/types';
 import type { Knex } from 'knex';
 import type { DatabaseClient } from '../../../types/index.js';
 import { DatabaseHelper } from '../types.js';
@@ -19,11 +20,13 @@ export type SortRecord = {
 export declare abstract class SchemaHelper extends DatabaseHelper {
     isOneOfClients(clients: DatabaseClient[]): boolean;
     changeNullable(table: string, column: string, nullable: boolean): Promise<void>;
+    generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
     protected changeToTypeByCopy(table: string, column: string, type: (typeof KNEX_TYPES)[number], options: Options): Promise<void>;
     preColumnChange(): Promise<boolean>;
     postColumnChange(): Promise<void>;
     preRelationChange(_relation: Partial<Relation>): void;
+    setNullable(column: Knex.ColumnBuilder, field: RawField | Field, existing: Column | null): void;
     processFieldType(field: Field): Type;
     constraintName(existingName: string): string;
     applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;

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

@@ -1,3 +1,4 @@
+import { getDefaultIndexName } from '../../../utils/get-default-index-name.js';
 import { getDatabaseClient } from '../../index.js';
 import { DatabaseHelper } from '../types.js';
 export class SchemaHelper extends DatabaseHelper {
@@ -14,6 +15,9 @@ export class SchemaHelper extends DatabaseHelper {
             }
         });
     }
+    generateIndexName(type, collection, fields) {
+        return getDefaultIndexName(type, collection, fields);
+    }
     async changeToType(table, column, type, options = {}) {
         await this.knex.schema.alterTable(table, (builder) => {
             const b = type === 'string' ? builder.string(column, options.length) : builder[type](column);
@@ -62,6 +66,15 @@ export class SchemaHelper extends DatabaseHelper {
     preRelationChange(_relation) {
         return;
     }
+    setNullable(column, field, existing) {
+        const isNullable = field.schema?.is_nullable ?? existing?.is_nullable ?? true;
+        if (isNullable) {
+            column.nullable();
+        }
+        else {
+            column.notNullable();
+        }
+    }
     processFieldType(field) {
         return field.type;
     }

package/dist/database/run-ast/utils/merge-with-parent-items.js

@@ -7,17 +7,27 @@ export function mergeWithParentItems(schema, nestedItem, parentItem, nestedNode,
     const parentItems = clone(toArray(parentItem));
     if (nestedNode.type === 'm2o') {
         const parentsByForeignKey = new Map();
-        parentItems.forEach((parentItem) => {
+        // default all nested nodes to null
+        for (const parentItem of parentItems) {
             const relationKey = parentItem[nestedNode.relation.field];
             if (!parentsByForeignKey.has(relationKey)) {
                 parentsByForeignKey.set(relationKey, []);
             }
             parentItem[nestedNode.fieldKey] = null;
             parentsByForeignKey.get(relationKey).push(parentItem);
-        });
-        const nestPrimaryKeyField = schema.collections[nestedNode.relation.related_collection].primary;
+        }
+        const nestedPrimaryKeyField = schema.collections[nestedNode.relation.related_collection].primary;
+        // populate nested items where applicable
         for (const nestedItem of nestedItems) {
-            const nestedPK = nestedItem[nestPrimaryKeyField];
+            const nestedPK = nestedItem[nestedPrimaryKeyField];
+            // user has no access to the nestedItem PK field
+            if (nestedPK === null) {
+                continue;
+            }
+            // Existing M2O record (i.e. valid nested PK) but not linked to this (or any) parent item
+            if (!parentsByForeignKey.has(nestedPK)) {
+                continue;
+            }
             for (const parentItem of parentsByForeignKey.get(nestedPK)) {
                 parentItem[nestedNode.fieldKey] = nestedItem;
             }
@@ -29,30 +39,44 @@ export function mergeWithParentItems(schema, nestedItem, parentItem, nestedNode,
         const parentRelationField = nestedNode.fieldKey;
         const nestedParentKeyField = nestedNode.relation.field;
         const parentsByPrimaryKey = new Map();
-        parentItems.forEach((parentItem) => {
-            if (!parentItem[parentRelationField])
+        for (const parentItem of parentItems) {
+            if (!parentItem[parentRelationField]) {
                 parentItem[parentRelationField] = [];
-            const parentPrimaryKey = parentItem[parentPrimaryKeyField];
+            }
+            let parentPrimaryKey = parentItem[parentPrimaryKeyField];
+            // null if the user has no access to parent PK
+            if (parentPrimaryKey === null) {
+                continue;
+            }
+            else {
+                // ensure key access is type agnostic
+                parentPrimaryKey = parentPrimaryKey.toString();
+            }
             if (parentsByPrimaryKey.has(parentPrimaryKey)) {
                 throw new Error(`Duplicate parent primary key '${parentPrimaryKey}' of '${parentCollectionName}' when merging o2m nested items`);
             }
             parentsByPrimaryKey.set(parentPrimaryKey, parentItem);
-        });
+        }
         const toAddToAllParents = [];
-        nestedItems.forEach((nestedItem) => {
-            if (nestedItem === null)
-                return;
+        for (const nestedItem of nestedItems) {
+            if (nestedItem === null) {
+                continue;
+            }
             if (Array.isArray(nestedItem[nestedParentKeyField])) {
                 toAddToAllParents.push(nestedItem); // TODO explain this odd case
-                return; // Avoids adding the nestedItem twice
+                continue; // Avoids adding the nestedItem twice
             }
             const parentPrimaryKey = nestedItem[nestedParentKeyField]?.[parentPrimaryKeyField] ?? nestedItem[nestedParentKeyField];
-            const parentItem = parentsByPrimaryKey.get(parentPrimaryKey);
+            if (parentPrimaryKey === null) {
+                continue;
+            }
+            const parentItem = parentsByPrimaryKey.get(parentPrimaryKey.toString());
+            // null if the user has no access to parent PK
             if (!parentItem) {
-                throw new Error(`Missing parentItem '${nestedItem[nestedParentKeyField]}' of '${parentCollectionName}' when merging o2m nested items`);
+                continue;
             }
             parentItem[parentRelationField].push(nestedItem);
-        });
+        }
         for (const [index, parentItem] of parentItems.entries()) {
             if (fieldAllowed === false || (isArray(fieldAllowed) && !fieldAllowed[index])) {
                 parentItem[nestedNode.fieldKey] = null;

package/dist/middleware/respond.js

@@ -17,7 +17,8 @@ export const respond = asyncHandler(async (req, res) => {
     if (env['CACHE_VALUE_MAX_SIZE'] !== false) {
         const valueSize = res.locals['payload'] ? stringByteSize(JSON.stringify(res.locals['payload'])) : 0;
         const maxSize = parseBytesConfiguration(env['CACHE_VALUE_MAX_SIZE']);
-        exceedsMaxSize = valueSize > maxSize;
+        if (maxSize !== null)
+            exceedsMaxSize = valueSize > maxSize;
     }
     if ((req.method.toLowerCase() === 'get' || req.originalUrl?.startsWith('/graphql')) &&
         req.originalUrl?.startsWith('/auth') === false &&

package/dist/operations/mail/index.d.ts

@@ -1,10 +1,13 @@
 export type Options = {
-    body?: string;
-    template?: string;
-    data?: Record<string, any>;
     to: string;
     type: 'wysiwyg' | 'markdown' | 'template';
     subject: string;
+    body?: string;
+    template?: string;
+    data?: Record<string, any>;
+    cc?: string;
+    bcc?: string;
+    replyTo?: string;
 };
 declare const _default: import("@directus/extensions").OperationApiConfig<Options>;
 export default _default;

package/dist/operations/mail/index.js

@@ -5,9 +5,9 @@ import { useLogger } from '../../logger/index.js';
 const logger = useLogger();
 export default defineOperationApi({
     id: 'mail',
-    handler: async ({ body, template, data, to, type, subject }, { accountability, database, getSchema }) => {
+    handler: async ({ body, template, data, to, type, subject, cc, bcc, replyTo }, { accountability, database, getSchema }) => {
         const mailService = new MailService({ schema: await getSchema({ database }), accountability, knex: database });
-        const mailObject = { to, subject };
+        const mailObject = { to, subject, cc, bcc, replyTo };
         const safeBody = typeof body !== 'string' ? JSON.stringify(body) : body;
         if (type === 'template') {
             mailObject.template = {

package/dist/services/collections.js

@@ -101,7 +101,7 @@ export class CollectionsService {
                     await trx.schema.createTable(payload.collection, (table) => {
                         for (const field of payload.fields) {
                             if (field.type && ALIAS_TYPES.includes(field.type) === false) {
-                                fieldsService.addColumnToTable(table, field);
+                                fieldsService.addColumnToTable(table, payload.collection, field);
                             }
                         }
                     });

package/dist/services/fields.d.ts

@@ -30,5 +30,5 @@ export declare class FieldsService {
     updateField(collection: string, field: RawField, opts?: MutationOptions): Promise<string>;
     updateFields(collection: string, fields: RawField[], opts?: MutationOptions): Promise<string[]>;
     deleteField(collection: string, field: string, opts?: MutationOptions): Promise<void>;
-    addColumnToTable(table: Knex.CreateTableBuilder, field: RawField | Field, existing?: Column | null): void;
+    addColumnToTable(table: Knex.CreateTableBuilder, collection: string, field: RawField | Field, existing?: Column | null): void;
 }

package/dist/services/fields.js

@@ -289,11 +289,11 @@ export class FieldsService {
                     : field;
                 if (hookAdjustedField.type && ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
                     if (table) {
-                        this.addColumnToTable(table, hookAdjustedField);
+                        this.addColumnToTable(table, collection, hookAdjustedField);
                     }
                     else {
                         await trx.schema.alterTable(collection, (table) => {
-                            this.addColumnToTable(table, hookAdjustedField);
+                            this.addColumnToTable(table, collection, hookAdjustedField);
                         });
                     }
                 }
@@ -397,7 +397,7 @@ export class FieldsService {
                             await trx.schema.alterTable(collection, async (table) => {
                                 if (!hookAdjustedField.schema)
                                     return;
-                                this.addColumnToTable(table, field, existingColumn);
+                                this.addColumnToTable(table, collection, field, existingColumn);
                             });
                         });
                     }
@@ -583,7 +583,17 @@ export class FieldsService {
                         .update({ group: null })
                         .where({ group: metaRow.field, collection: metaRow.collection });
                 }
-                await trx('directus_fields').delete().where({ collection, field });
+                const itemsService = new ItemsService('directus_fields', {
+                    knex: trx,
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                await itemsService.deleteByQuery({
+                    filter: {
+                        collection: { _eq: collection },
+                        field: { _eq: field },
+                    },
+                }, { emitEvents: false });
             });
             const actionEvent = {
                 event: 'fields.delete',
@@ -623,7 +633,7 @@ export class FieldsService {
             }
         }
     }
-    addColumnToTable(table, field, existing = null) {
+    addColumnToTable(table, collection, field, existing = null) {
         let column;
         // Don't attempt to add a DB column for alias / corrupt fields
         if (field.type === 'alias' || field.type === 'unknown')
@@ -664,7 +674,17 @@ export class FieldsService {
         else {
             throw new InvalidPayloadError({ reason: `Illegal type passed: "${field.type}"` });
         }
-        const setDefaultValue = (defaultValue) => {
+        /**
+         * The column nullability must be set on every alter or it will be dropped
+         * This is due to column.alter() not being incremental per https://knexjs.org/guide/schema-builder.html#alter
+         */
+        this.helpers.schema.setNullable(column, field, existing);
+        /**
+         * The default value must be set on every alter or it will be dropped
+         * This is due to column.alter() not being incremental per https://knexjs.org/guide/schema-builder.html#alter
+         */
+        const defaultValue = field.schema?.default_value !== undefined ? field.schema?.default_value : existing?.default_value;
+        if (defaultValue !== undefined) {
             const newDefaultValueIsString = typeof defaultValue === 'string';
             const newDefaultIsNowFunction = newDefaultValueIsString && defaultValue.toLowerCase() === 'now()';
             const newDefaultIsCurrentTimestamp = newDefaultValueIsString && defaultValue === 'CURRENT_TIMESTAMP';
@@ -684,34 +704,6 @@ export class FieldsService {
             else {
                 column.defaultTo(defaultValue);
             }
-        };
-        // for a new item, set the default value and nullable as provided without any further considerations
-        if (!existing) {
-            if (field.schema?.default_value !== undefined) {
-                setDefaultValue(field.schema.default_value);
-            }
-            if (field.schema?.is_nullable || field.schema?.is_nullable === undefined) {
-                column.nullable();
-            }
-            else {
-                column.notNullable();
-            }
-        }
-        else {
-            // for an existing item: if nullable option changed, we have to provide the default values as well and actually vice versa
-            // see https://knexjs.org/guide/schema-builder.html#alter
-            // To overwrite a nullable option with the same value this is not possible for Oracle though, hence the DB helper
-            if (field.schema?.default_value !== undefined || field.schema?.is_nullable !== undefined) {
-                this.helpers.nullableUpdate.updateNullableValue(column, field, existing);
-                let defaultValue = null;
-                if (field.schema?.default_value !== undefined) {
-                    defaultValue = field.schema.default_value;
-                }
-                else if (existing.default_value !== undefined) {
-                    defaultValue = existing.default_value;
-                }
-                setDefaultValue(defaultValue);
-            }
         }
         if (field.schema?.is_primary_key) {
             column.primary().notNullable();
@@ -720,19 +712,23 @@ export class FieldsService {
             // primary key will already have unique/index constraints
             if (field.schema?.is_unique === true) {
                 if (!existing || existing.is_unique === false) {
-                    column.unique();
+                    column.unique({ indexName: this.helpers.schema.generateIndexName('unique', collection, field.field) });
                 }
             }
             else if (field.schema?.is_unique === false) {
-                if (existing && existing.is_unique === true) {
-                    table.dropUnique([field.field]);
+                if (existing?.is_unique === true) {
+                    table.dropUnique([field.field], this.helpers.schema.generateIndexName('unique', collection, field.field));
                 }
             }
-            if (field.schema?.is_indexed === true && !existing?.is_indexed) {
-                column.index();
+            if (field.schema?.is_indexed === true) {
+                if (!existing || existing.is_indexed === false) {
+                    column.index(this.helpers.schema.generateIndexName('index', collection, field.field));
+                }
             }
-            else if (field.schema?.is_indexed === false && existing?.is_indexed) {
-                table.dropIndex([field.field]);
+            else if (field.schema?.is_indexed === false) {
+                if (existing?.is_indexed === true) {
+                    table.dropIndex([field.field], this.helpers.schema.generateIndexName('index', collection, field.field));
+                }
             }
         }
         if (existing) {

package/dist/services/files.js

@@ -1,5 +1,5 @@
 import { useEnv } from '@directus/env';
-import { ContentTooLargeError, ForbiddenError, InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
+import { ContentTooLargeError, InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
 import formatTitle from '@directus/format-title';
 import { toArray } from '@directus/utils';
 import encodeURL from 'encodeurl';
@@ -211,10 +211,11 @@ export class FilesService extends ItemsService {
      */
     async deleteMany(keys) {
         const storage = await getStorage();
-        const files = await super.readMany(keys, { fields: ['id', 'storage', 'filename_disk'], limit: -1 });
-        if (!files) {
-            throw new ForbiddenError();
-        }
+        const sudoFilesItemsService = new FilesService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const files = await sudoFilesItemsService.readMany(keys, { fields: ['id', 'storage', 'filename_disk'], limit: -1 });
         await super.deleteMany(keys);
         for (const file of files) {
             const disk = storage.location(file['storage']);

package/dist/services/tus/data-store.d.ts

@@ -5,8 +5,8 @@ import { DataStore, Upload } from '@tus/utils';
 export type TusDataStoreConfig = {
     constants: {
         ENABLED: boolean;
-        CHUNK_SIZE: number;
-        MAX_SIZE: number;
+        CHUNK_SIZE: number | null;
+        MAX_SIZE: number | null;
         EXPIRATION_TIME: number;
         SCHEDULE: string;
     };
@@ -17,8 +17,8 @@ export type TusDataStoreConfig = {
     accountability: Accountability | undefined;
 };
 export declare class TusDataStore extends DataStore {
-    protected chunkSize: number;
-    protected maxSize: number;
+    protected chunkSize: number | undefined;
+    protected maxSize: number | undefined;
     protected expirationTime: number;
     protected location: string;
     protected storageDriver: TusDriver;

package/dist/services/tus/data-store.js

@@ -17,8 +17,10 @@ export class TusDataStore extends DataStore {
     accountability;
     constructor(config) {
         super();
-        this.chunkSize = config.constants.CHUNK_SIZE;
-        this.maxSize = config.constants.MAX_SIZE;
+        if (config.constants.CHUNK_SIZE !== null)
+            this.chunkSize = config.constants.CHUNK_SIZE;
+        if (config.constants.MAX_SIZE !== null)
+            this.maxSize = config.constants.MAX_SIZE;
         this.expirationTime = config.constants.EXPIRATION_TIME;
         this.location = config.location;
         this.storageDriver = config.driver;

package/dist/services/tus/server.js

@@ -37,7 +37,7 @@ export async function createTusServer(context) {
         path: '/files/tus',
         datastore: store,
         locker: getTusLocker(),
-        maxSize: RESUMABLE_UPLOADS.MAX_SIZE,
+        ...(RESUMABLE_UPLOADS.MAX_SIZE !== null && { maxSize: RESUMABLE_UPLOADS.MAX_SIZE }),
         async onUploadFinish(req, res, upload) {
             const service = new ItemsService('directus_files', {
                 schema: req.schema,

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

@@ -21,5 +21,5 @@ type GetColumnOptions = OriginalCollectionName | (FunctionColumnOptions & Origin
  * @param options Optional parameters
  * @returns Knex raw instance
  */
-export declare function getColumn(knex: Knex, table: string, column: string, alias: (string | false) | undefined, schema: SchemaOverview, options?: GetColumnOptions): Knex.Raw;
+export declare function getColumn(knex: Knex, table: string, column: string, alias: string | false | undefined, schema: SchemaOverview, options?: GetColumnOptions): Knex.Raw;
 export {};

package/dist/utils/get-default-index-name.d.ts

@@ -1,10 +1,13 @@
+export type GetDefaultIndexNameOptions = {
+    maxLength?: number;
+};
 /**
  * Generate an index name for a given collection + fields combination.
  *
- * Is based on the default index name generation of knex, but limits the index to a maximum of 64
- * characters (the max length for MySQL and MariaDB).
+ * Based on the default index name generation of knex, with the caveat that it limits the index to options.maxLength
+ * which defaults to 60 characters.
  *
  * @see
  * https://github.com/knex/knex/blob/fff6eb15d7088d4198650a2c6e673dedaf3b8f36/lib/schema/tablecompiler.js#L282-L297
  */
-export declare function getDefaultIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
+export declare function getDefaultIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[], options?: GetDefaultIndexNameOptions): string;

package/dist/utils/get-default-index-name.js

@@ -2,20 +2,21 @@ import { getSimpleHash } from '@directus/utils';
 /**
  * Generate an index name for a given collection + fields combination.
  *
- * Is based on the default index name generation of knex, but limits the index to a maximum of 64
- * characters (the max length for MySQL and MariaDB).
+ * Based on the default index name generation of knex, with the caveat that it limits the index to options.maxLength
+ * which defaults to 60 characters.
  *
  * @see
  * https://github.com/knex/knex/blob/fff6eb15d7088d4198650a2c6e673dedaf3b8f36/lib/schema/tablecompiler.js#L282-L297
  */
-export function getDefaultIndexName(type, collection, fields) {
+export function getDefaultIndexName(type, collection, fields, options) {
+    const maxLength = options?.maxLength ?? 60;
     if (!Array.isArray(fields))
         fields = fields ? [fields] : [];
     const table = collection.replace(/\.|-/g, '_');
     const indexName = (table + '_' + fields.join('_') + '_' + type).toLowerCase();
-    if (indexName.length <= 60)
+    if (indexName.length <= maxLength)
         return indexName;
     const suffix = `__${getSimpleHash(indexName)}_${type}`;
-    const prefix = indexName.substring(0, 60 - suffix.length);
+    const prefix = indexName.substring(0, maxLength - suffix.length);
     return `${prefix}${suffix}`;
 }

package/dist/utils/get-schema.js

@@ -44,10 +44,10 @@ export async function getSchema(options, attempt = 0) {
         const subscription = new Promise((resolve, reject) => {
             bus.subscribe(messageKey, busListener).catch(reject);
             function busListener(options) {
+                cleanup();
                 if (options.schema === null) {
                     return reject();
                 }
-                cleanup();
                 setLocalSchemaCache(options.schema).catch(reject);
                 resolve(options.schema);
             }

package/dist/utils/sanitize-schema.d.ts

@@ -16,7 +16,7 @@ export declare function sanitizeCollection(collection: Collection | undefined):
  * @returns sanitized field
  */
 export declare function sanitizeField(field: Field | undefined, sanitizeAllSchema?: boolean): Partial<Field> | undefined;
-export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "name" | "numeric_precision" | "data_type" | "default_value" | "max_length" | "numeric_scale" | "is_nullable" | "is_unique" | "is_indexed" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
+export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "name" | "data_type" | "default_value" | "max_length" | "numeric_precision" | "numeric_scale" | "is_nullable" | "is_unique" | "is_indexed" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
 /**
  * Pick certain database vendor specific relation properties that should be compared when performing diff
  *

package/license

@@ -1,7 +1,7 @@
 Licensor:             Monospace, Inc.
 
 Licensed Work:        Directus
-                      The Licensed Work is Copyright © 2024 Monospace, Inc.
+                      The Licensed Work is Copyright © 2025 Monospace, Inc.
 
 Additional Use Grant: You may use the Licensed Work in production as long as
                       your Total Finances do not exceed US $5,000,000 for the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "23.3.2",
+  "version": "24.0.1",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -59,127 +59,126 @@
   ],
   "dependencies": {
     "@authenio/samlify-node-xmllint": "2.0.0",
-    "@aws-sdk/client-ses": "3.668.0",
+    "@aws-sdk/client-ses": "3.723.0",
     "@godaddy/terminus": "4.12.1",
     "@rollup/plugin-alias": "5.1.1",
-    "@rollup/plugin-node-resolve": "15.3.0",
+    "@rollup/plugin-node-resolve": "15.3.1",
     "@rollup/plugin-virtual": "3.0.2",
-    "@tus/file-store": "1.5.0",
-    "@tus/server": "1.9.0",
-    "@tus/utils": "0.4.0",
-    "@types/cookie": "0.6.0",
+    "@tus/server": "1.10.0",
+    "@tus/utils": "0.5.0",
     "argon2": "0.41.1",
     "async": "3.2.6",
-    "axios": "1.7.7",
+    "axios": "1.7.9",
     "busboy": "1.6.0",
     "bytes": "3.1.2",
     "camelcase": "8.0.0",
-    "chalk": "5.3.0",
+    "chalk": "5.4.1",
     "chokidar": "3.6.0",
     "commander": "12.1.0",
     "content-disposition": "0.5.4",
-    "cookie": "0.7.2",
+    "cookie": "1.0.2",
     "cookie-parser": "1.4.7",
     "cors": "2.8.5",
     "cron-parser": "4.9.0",
     "date-fns": "4.1.0",
     "deep-diff": "1.0.2",
     "destroy": "1.2.0",
-    "dotenv": "16.4.5",
+    "dotenv": "16.4.7",
     "encodeurl": "2.0.0",
     "eventemitter2": "6.4.9",
     "execa": "8.0.1",
     "exif-reader": "2.0.1",
-    "express": "4.20.0",
+    "express": "4.21.2",
     "flat": "6.0.1",
     "fs-extra": "11.2.0",
     "glob-to-regexp": "0.4.1",
-    "graphql": "16.9.0",
+    "graphql": "16.10.0",
     "graphql-compose": "9.0.11",
-    "graphql-ws": "5.16.0",
+    "graphql-ws": "5.16.1",
     "helmet": "8.0.0",
     "icc": "3.0.0",
-    "inquirer": "12.0.0",
-    "ioredis": "5.4.1",
+    "inquirer": "12.3.0",
+    "ioredis": "5.4.2",
     "ip-matching": "2.1.2",
-    "isolated-vm": "5.0.1",
+    "isolated-vm": "5.0.3",
     "joi": "17.13.3",
     "js-yaml": "4.1.0",
     "js2xmlparser": "5.0.0",
     "json2csv": "5.0.7",
     "jsonwebtoken": "9.0.2",
-    "keyv": "5.1.0",
+    "keyv": "5.2.3",
     "knex": "3.1.0",
     "ldapjs": "2.3.3",
-    "liquidjs": "10.17.0",
+    "liquidjs": "10.20.1",
     "lodash-es": "4.17.21",
-    "marked": "14.1.2",
+    "marked": "15.0.6",
     "micromustache": "8.0.3",
     "mime-types": "2.1.35",
-    "minimatch": "9.0.5",
+    "minimatch": "10.0.1",
     "mnemonist": "0.39.8",
     "ms": "2.1.3",
-    "nanoid": "5.0.7",
+    "nanoid": "5.0.9",
     "node-machine-id": "1.1.12",
     "node-schedule": "2.1.1",
-    "nodemailer": "6.9.15",
+    "nodemailer": "6.9.16",
     "object-hash": "3.0.0",
     "openapi3-ts": "4.4.0",
-    "openid-client": "5.7.0",
-    "ora": "8.1.0",
+    "openid-client": "5.7.1",
+    "ora": "8.1.1",
     "otplib": "12.0.1",
-    "p-limit": "6.1.0",
+    "p-limit": "6.2.0",
     "p-queue": "8.0.1",
     "papaparse": "5.4.1",
-    "pino": "9.4.0",
+    "pino": "9.6.0",
     "pino-http": "10.3.0",
     "pino-http-print": "3.1.0",
-    "pino-pretty": "11.2.2",
-    "qs": "6.13.0",
-    "rate-limiter-flexible": "5.0.3",
-    "rollup": "4.17.2",
+    "pino-pretty": "13.0.0",
+    "qs": "6.13.1",
+    "rate-limiter-flexible": "5.0.4",
+    "rollup": "4.30.1",
     "samlify": "2.8.10",
-    "sanitize-html": "2.13.1",
+    "sanitize-html": "2.14.0",
     "sharp": "0.33.5",
     "snappy": "7.2.2",
-    "stream-json": "1.8.0",
+    "stream-json": "1.9.1",
     "tar": "7.4.3",
-    "tsx": "4.19.1",
+    "tsx": "4.19.2",
     "wellknown": "0.5.0",
     "ws": "8.18.0",
-    "zod": "3.23.8",
+    "zod": "3.24.1",
     "zod-validation-error": "3.4.0",
-    "@directus/app": "13.4.0",
-    "@directus/constants": "12.0.1",
-    "@directus/env": "4.1.0",
-    "@directus/errors": "1.0.1",
-    "@directus/extensions": "2.0.6",
-    "@directus/extensions-registry": "2.0.6",
-    "@directus/extensions-sdk": "12.1.4",
-    "@directus/format-title": "11.0.0",
-    "@directus/memory": "2.0.6",
-    "@directus/pressure": "2.0.5",
-    "@directus/schema": "12.1.1",
+    "@directus/app": "13.6.0",
+    "@directus/constants": "13.0.0",
+    "@directus/env": "5.0.0",
+    "@directus/errors": "2.0.0",
+    "@directus/extensions": "3.0.1",
+    "@directus/extensions-registry": "3.0.1",
+    "@directus/extensions-sdk": "13.0.1",
+    "@directus/format-title": "12.0.0",
+    "@directus/memory": "3.0.0",
+    "@directus/schema": "13.0.0",
     "@directus/specs": "11.1.0",
-    "@directus/storage-driver-azure": "11.1.2",
-    "@directus/storage": "11.0.1",
-    "@directus/storage-driver-cloudinary": "11.1.2",
-    "@directus/storage-driver-gcs": "11.1.2",
-    "@directus/storage-driver-local": "11.0.1",
-    "@directus/storage-driver-s3": "11.0.5",
-    "@directus/storage-driver-supabase": "2.1.2",
-    "@directus/system-data": "2.1.2",
-    "@directus/validation": "1.0.5",
-    "@directus/utils": "12.0.5",
-    "directus": "11.3.5"
+    "@directus/storage-driver-azure": "12.0.0",
+    "@directus/pressure": "3.0.0",
+    "@directus/storage": "12.0.0",
+    "@directus/storage-driver-cloudinary": "12.0.0",
+    "@directus/storage-driver-local": "12.0.0",
+    "@directus/storage-driver-gcs": "12.0.0",
+    "@directus/storage-driver-s3": "12.0.0",
+    "@directus/storage-driver-supabase": "3.0.0",
+    "@directus/utils": "13.0.0",
+    "@directus/system-data": "3.0.0",
+    "@directus/validation": "2.0.0",
+    "directus": "11.4.1"
   },
   "devDependencies": {
-    "@ngneat/falso": "7.2.0",
+    "@directus/tsconfig": "3.0.0",
+    "@ngneat/falso": "7.3.0",
     "@types/async": "3.2.24",
     "@types/busboy": "1.5.4",
-    "@types/bytes": "3.1.4",
+    "@types/bytes": "3.1.5",
     "@types/content-disposition": "0.5.8",
-    "@types/cookie-parser": "1.4.7",
+    "@types/cookie-parser": "1.4.8",
     "@types/cors": "2.8.17",
     "@types/deep-diff": "1.0.5",
     "@types/destroy": "1.0.3",
@@ -196,38 +195,37 @@
     "@types/lodash-es": "4.17.12",
     "@types/mime-types": "2.1.4",
     "@types/ms": "0.7.34",
-    "@types/node": "18.19.55",
+    "@types/node": "22.10.5",
     "@types/node-schedule": "2.1.7",
-    "@types/nodemailer": "6.4.16",
+    "@types/nodemailer": "6.4.17",
     "@types/object-hash": "3.0.6",
-    "@types/papaparse": "5.3.14",
-    "@types/qs": "6.9.16",
+    "@types/papaparse": "5.3.15",
+    "@types/qs": "6.9.17",
     "@types/sanitize-html": "2.13.0",
-    "@types/stream-json": "1.7.7",
+    "@types/stream-json": "1.7.8",
     "@types/wellknown": "0.5.8",
-    "@types/ws": "8.5.12",
-    "@vitest/coverage-v8": "2.1.2",
+    "@types/ws": "8.5.13",
+    "@vitest/coverage-v8": "2.1.8",
     "copyfiles": "2.4.1",
     "form-data": "4.0.1",
     "get-port": "7.1.0",
     "knex-mock-client": "3.0.2",
-    "typescript": "5.6.3",
-    "vitest": "2.1.2",
-    "@directus/random": "1.0.0",
-    "@directus/tsconfig": "2.0.0",
-    "@directus/types": "12.2.2"
+    "typescript": "5.7.3",
+    "vitest": "2.1.8",
+    "@directus/random": "2.0.0",
+    "@directus/types": "13.0.0"
   },
   "optionalDependencies": {
     "@keyv/redis": "3.0.1",
-    "mysql2": "3.11.3",
+    "mysql2": "3.12.0",
     "nodemailer-mailgun-transport": "2.1.5",
-    "oracledb": "6.6.0",
-    "pg": "8.13.0",
+    "oracledb": "6.7.1",
+    "pg": "8.13.1",
     "sqlite3": "5.1.7",
     "tedious": "18.6.1"
   },
   "engines": {
-    "node": ">=18.17.0"
+    "node": ">=22"
   },
   "scripts": {
     "build": "tsc --project tsconfig.prod.json && copyfiles \"src/**/*.{yaml,liquid}\" -u 1 dist",

package/dist/database/helpers/nullable-update/dialects/default.d.ts

@@ -1,3 +0,0 @@
-import { NullableFieldUpdateHelper } from '../types.js';
-export declare class NullableFieldUpdateHelperDefault extends NullableFieldUpdateHelper {
-}

package/dist/database/helpers/nullable-update/dialects/default.js

@@ -1,3 +0,0 @@
-import { NullableFieldUpdateHelper } from '../types.js';
-export class NullableFieldUpdateHelperDefault extends NullableFieldUpdateHelper {
-}

package/dist/database/helpers/nullable-update/dialects/oracle.d.ts

@@ -1,12 +0,0 @@
-import type { Column } from '@directus/schema';
-import type { Field, RawField } from '@directus/types';
-import type { Knex } from 'knex';
-import { NullableFieldUpdateHelper } from '../types.js';
-/**
- * Oracle throws an error when overwriting the nullable option with same value.
- * Therefore we need to check if the nullable option has changed and only then apply it.
- * The default value can be set regardless of the previous value.
- */
-export declare class NullableFieldUpdateHelperOracle extends NullableFieldUpdateHelper {
-    updateNullableValue(column: Knex.ColumnBuilder, field: RawField | Field, existing: Column): void;
-}

package/dist/database/helpers/nullable-update/dialects/oracle.js

@@ -1,16 +0,0 @@
-import { NullableFieldUpdateHelper } from '../types.js';
-/**
- * Oracle throws an error when overwriting the nullable option with same value.
- * Therefore we need to check if the nullable option has changed and only then apply it.
- * The default value can be set regardless of the previous value.
- */
-export class NullableFieldUpdateHelperOracle extends NullableFieldUpdateHelper {
-    updateNullableValue(column, field, existing) {
-        if (field.schema?.is_nullable === false && existing.is_nullable === true) {
-            column.notNullable();
-        }
-        else if (field.schema?.is_nullable === true && existing.is_nullable === false) {
-            column.nullable();
-        }
-    }
-}

package/dist/database/helpers/nullable-update/index.d.ts

@@ -1,7 +0,0 @@
-export { NullableFieldUpdateHelperOracle as oracle } from './dialects/oracle.js';
-export { NullableFieldUpdateHelperDefault as postgres } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as mysql } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as cockroachdb } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as redshift } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as sqlite } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as mssql } from './dialects/default.js';

package/dist/database/helpers/nullable-update/index.js

@@ -1,7 +0,0 @@
-export { NullableFieldUpdateHelperOracle as oracle } from './dialects/oracle.js';
-export { NullableFieldUpdateHelperDefault as postgres } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as mysql } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as cockroachdb } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as redshift } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as sqlite } from './dialects/default.js';
-export { NullableFieldUpdateHelperDefault as mssql } from './dialects/default.js';

package/dist/database/helpers/nullable-update/types.d.ts

@@ -1,7 +0,0 @@
-import type { Knex } from 'knex';
-import { DatabaseHelper } from '../types.js';
-import type { Column } from '@directus/schema';
-import type { Field, RawField } from '@directus/types';
-export declare class NullableFieldUpdateHelper extends DatabaseHelper {
-    updateNullableValue(column: Knex.ColumnBuilder, field: RawField | Field, existing: Column): void;
-}

package/dist/database/helpers/nullable-update/types.js

@@ -1,12 +0,0 @@
-import { DatabaseHelper } from '../types.js';
-export class NullableFieldUpdateHelper extends DatabaseHelper {
-    updateNullableValue(column, field, existing) {
-        const isNullable = field.schema?.is_nullable ?? existing?.is_nullable ?? true;
-        if (isNullable) {
-            column.nullable();
-        }
-        else {
-            column.notNullable();
-        }
-    }
-}