@directus/api 9.25.0

package/dist/database/migrations/20201105A-add-cascade-system-relations.d.ts

@@ -0,0 +1,8 @@
+import type { Knex } from 'knex';
+/**
+ * NOTE:
+ * Not all databases allow (or support) recursive onUpdate/onDelete triggers. MS SQL / Oracle flat out deny creating them,
+ * Postgres behaves erratic on those triggers, not sure if MySQL / Maria plays nice either.
+ */
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20201105A-add-cascade-system-relations.js

@@ -0,0 +1,131 @@
+const updates = [
+    {
+        table: 'directus_fields',
+        constraints: [
+            {
+                column: 'group',
+                references: 'directus_fields.id',
+            },
+        ],
+    },
+    {
+        table: 'directus_files',
+        constraints: [
+            {
+                column: 'folder',
+                references: 'directus_folders.id',
+            },
+            {
+                column: 'uploaded_by',
+                references: 'directus_users.id',
+            },
+            {
+                column: 'modified_by',
+                references: 'directus_users.id',
+            },
+        ],
+    },
+    {
+        table: 'directus_folders',
+        constraints: [
+            {
+                column: 'parent',
+                references: 'directus_folders.id',
+            },
+        ],
+    },
+    {
+        table: 'directus_permissions',
+        constraints: [
+            {
+                column: 'role',
+                references: 'directus_roles.id',
+            },
+        ],
+    },
+    {
+        table: 'directus_presets',
+        constraints: [
+            {
+                column: 'user',
+                references: 'directus_users.id',
+            },
+            {
+                column: 'role',
+                references: 'directus_roles.id',
+            },
+        ],
+    },
+    {
+        table: 'directus_revisions',
+        constraints: [
+            {
+                column: 'activity',
+                references: 'directus_activity.id',
+            },
+            {
+                column: 'parent',
+                references: 'directus_revisions.id',
+            },
+        ],
+    },
+    {
+        table: 'directus_sessions',
+        constraints: [
+            {
+                column: 'user',
+                references: 'directus_users.id',
+            },
+        ],
+    },
+    {
+        table: 'directus_settings',
+        constraints: [
+            {
+                column: 'project_logo',
+                references: 'directus_files.id',
+            },
+            {
+                column: 'public_foreground',
+                references: 'directus_files.id',
+            },
+            {
+                column: 'public_background',
+                references: 'directus_files.id',
+            },
+        ],
+    },
+    {
+        table: 'directus_users',
+        constraints: [
+            {
+                column: 'role',
+                references: 'directus_roles.id',
+            },
+        ],
+    },
+];
+/**
+ * NOTE:
+ * Not all databases allow (or support) recursive onUpdate/onDelete triggers. MS SQL / Oracle flat out deny creating them,
+ * Postgres behaves erratic on those triggers, not sure if MySQL / Maria plays nice either.
+ */
+export async function up(knex) {
+    for (const update of updates) {
+        await knex.schema.alterTable(update.table, (table) => {
+            for (const constraint of update.constraints) {
+                table.dropForeign([constraint.column]);
+                table.foreign(constraint.column).references(constraint.references);
+            }
+        });
+    }
+}
+export async function down(knex) {
+    for (const update of updates) {
+        await knex.schema.alterTable(update.table, (table) => {
+            for (const constraint of update.constraints) {
+                table.dropForeign([constraint.column]);
+            }
+        });
+    }
+}

package/dist/database/migrations/20201105B-change-webhook-url-type.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/20201105B-change-webhook-url-type.js

@@ -0,0 +1,12 @@
+import { getHelpers } from '../helpers/index.js';
+export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    const type = helper.isOneOfClients(['oracle', 'cockroachdb']) ? 'text' : 'string';
+    await helper.changeToType('directus_webhooks', 'url', type);
+}
+export async function down(knex) {
+    await getHelpers(knex).schema.changeToType('directus_webhooks', 'url', 'string', {
+        nullable: false,
+        length: 255,
+    });
+}

package/dist/database/migrations/20210225A-add-relations-sort-field.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/20210225A-add-relations-sort-field.js

@@ -0,0 +1,28 @@
+import { parseJSON } from '@directus/utils';
+export async function up(knex) {
+    await knex.schema.alterTable('directus_relations', (table) => {
+        table.string('sort_field');
+    });
+    const fieldsWithSort = await knex
+        .select('collection', 'field', 'options')
+        .from('directus_fields')
+        .whereIn('interface', ['one-to-many', 'm2a-builder', 'many-to-many']);
+    for (const field of fieldsWithSort) {
+        const options = typeof field.options === 'string' ? parseJSON(field.options) : field.options ?? {};
+        if ('sortField' in options) {
+            await knex('directus_relations')
+                .update({
+                sort_field: options.sortField,
+            })
+                .where({
+                one_collection: field.collection,
+                one_field: field.field,
+            });
+        }
+    }
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_relations', (table) => {
+        table.dropColumn('sort_field');
+    });
+}

package/dist/database/migrations/20210304A-remove-locked-fields.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/20210304A-remove-locked-fields.js

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

package/dist/database/migrations/20210312A-webhooks-collections-text.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/20210312A-webhooks-collections-text.js

@@ -0,0 +1,12 @@
+import { getHelpers } from '../helpers/index.js';
+export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    const type = helper.isOneOfClients(['oracle', 'cockroachdb']) ? 'text' : 'string';
+    await helper.changeToType('directus_webhooks', 'collections', type);
+}
+export async function down(knex) {
+    await getHelpers(knex).schema.changeToType('directus_webhooks', 'collections', 'string', {
+        nullable: false,
+        length: 255,
+    });
+}

package/dist/database/migrations/20210331A-add-refresh-interval.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/20210331A-add-refresh-interval.js

@@ -0,0 +1,10 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_presets', (table) => {
+        table.integer('refresh_interval');
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_presets', (table) => {
+        table.dropColumn('refresh_interval');
+    });
+}

package/dist/database/migrations/20210415A-make-filesize-nullable.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/20210415A-make-filesize-nullable.js

@@ -0,0 +1,15 @@
+import { getHelpers } from '../helpers/index.js';
+export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    await helper.changeToType('directus_files', 'filesize', 'integer', {
+        nullable: true,
+        default: null,
+    });
+}
+export async function down(knex) {
+    const helper = getHelpers(knex).schema;
+    await helper.changeToType('directus_files', 'filesize', 'integer', {
+        nullable: false,
+        default: 0,
+    });
+}

package/dist/database/migrations/20210416A-add-collections-accountability.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/20210416A-add-collections-accountability.js

@@ -0,0 +1,11 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_collections', (table) => {
+        table.string('accountability').defaultTo('all');
+    });
+    await knex('directus_collections').update({ accountability: 'all' });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_collections', (table) => {
+        table.dropColumn('accountability');
+    });
+}

package/dist/database/migrations/20210422A-remove-files-interface.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/20210422A-remove-files-interface.js

@@ -0,0 +1,6 @@
+export async function up(knex) {
+    await knex('directus_fields').update({ interface: 'many-to-many' }).where({ interface: 'files' });
+}
+export async function down(_knex) {
+    // Do nothing
+}

package/dist/database/migrations/20210506A-rename-interfaces.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/20210506A-rename-interfaces.js

@@ -0,0 +1,74 @@
+import { parseJSON } from '@directus/utils';
+// [before, after, after-option additions]
+const changes = [
+    ['button-links', 'presentation-links'],
+    ['checkboxes', 'select-multiple-checkbox'],
+    ['code', 'input-code'],
+    ['color', 'select-color'],
+    ['datetime', 'datetime'],
+    ['divider', 'presentation-divider'],
+    ['dropdown', 'select-dropdown'],
+    ['dropdown-multiselect', 'select-multiple-dropdown'],
+    ['file', 'file'],
+    ['hash', 'input-hash'],
+    ['icon', 'select-icon'],
+    ['image', 'file-image'],
+    ['m2a-builder', 'list-m2a'],
+    ['many-to-many', 'list-m2m'],
+    ['many-to-one', 'select-dropdown-m2o'],
+    ['markdown', 'input-rich-text-md'],
+    ['notice', 'presentation-notice'],
+    ['numeric', 'input'],
+    ['one-to-many', 'list-o2m'],
+    ['radio-buttons', 'select-radio'],
+    ['repeater', 'list'],
+    ['slider', 'slider'],
+    ['slug', 'input', { slug: true }],
+    ['tags', 'tags'],
+    ['text-input', 'input'],
+    ['textarea', 'input-multiline'],
+    ['toggle', 'boolean'],
+    ['translations', 'translations'],
+    ['tree-view', 'list-o2m-tree-view'],
+    ['user', 'select-dropdown-m2o', { template: '{{avatar.$thumbnail}} {{first_name}} {{last_name}}' }],
+    ['wysiwyg', 'input-rich-text-html'],
+    // System:
+    ['collection', 'system-collection'],
+    ['collections', 'system-collection-multiple'],
+    ['display-template', 'system-display-template'],
+    ['field', 'system-field'],
+    ['interface', 'system-interface'],
+    ['interface-options', 'system-interface-options'],
+    ['scope', 'system-scope'],
+    ['system-language', 'system-language'],
+    ['tfa-setup', 'system-mfa-setup'],
+];
+export async function up(knex) {
+    for (const [before, after, options] of changes) {
+        // If any options need to be added, update the fields one by one in order to update the pre-existing field options
+        if (options) {
+            const fields = await knex
+                .select('id', 'options')
+                .from('directus_fields')
+                .where({ interface: before });
+            for (const { id, options: existingOptionsRaw } of fields) {
+                const existingOptions = typeof existingOptionsRaw === 'string' ? parseJSON(existingOptionsRaw) : existingOptionsRaw;
+                const newOptions = {
+                    ...(existingOptions || {}),
+                    ...options,
+                };
+                await knex('directus_fields')
+                    .update({ interface: after, options: JSON.stringify(newOptions) })
+                    .where({ id });
+            }
+        }
+        else {
+            await knex('directus_fields').update({ interface: after }).where({ interface: before });
+        }
+    }
+}
+export async function down(knex) {
+    for (const [before, after] of changes) {
+        await knex('directus_fields').update({ interface: before }).where({ interface: after });
+    }
+}

package/dist/database/migrations/20210510A-restructure-relations.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/20210510A-restructure-relations.js

@@ -0,0 +1,27 @@
+import { getHelpers } from '../helpers/index.js';
+export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    await knex.schema.alterTable('directus_relations', (table) => {
+        table.dropColumns('many_primary', 'one_primary');
+        table.string('one_deselect_action').defaultTo('nullify');
+    });
+    await knex('directus_relations').update({ one_deselect_action: 'nullify' });
+    await helper.changeToType('directus_relations', 'sort_field', 'string', {
+        length: 64,
+    });
+    await helper.changeToType('directus_relations', 'one_deselect_action', 'string', {
+        nullable: false,
+        default: 'nullify',
+    });
+}
+export async function down(knex) {
+    const helper = getHelpers(knex).schema;
+    await helper.changeToType('directus_relations', 'sort_field', 'string', {
+        length: 255,
+    });
+    await knex.schema.alterTable('directus_relations', (table) => {
+        table.dropColumn('one_deselect_action');
+        table.string('many_primary', 64);
+        table.string('one_primary', 64);
+    });
+}

package/dist/database/migrations/20210518A-add-foreign-key-constraints.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/20210518A-add-foreign-key-constraints.js

@@ -0,0 +1,106 @@
+import { createInspector } from '@directus/schema';
+import logger from '../../logger.js';
+import { getDefaultIndexName } from '../../utils/get-default-index-name.js';
+export async function up(knex) {
+    const inspector = createInspector(knex);
+    const foreignKeys = await inspector.foreignKeys();
+    const relations = await knex
+        .select('id', 'many_collection', 'many_field', 'one_collection')
+        .from('directus_relations');
+    const constraintsToAdd = relations.filter((relation) => {
+        const exists = !!foreignKeys.find((fk) => fk.table === relation?.many_collection && fk.column === relation?.many_field);
+        return exists === false;
+    });
+    const corruptedRelations = [];
+    for (const constraint of constraintsToAdd) {
+        if (!constraint.one_collection)
+            continue;
+        if ((await inspector.hasTable(constraint.many_collection)) === false ||
+            (await inspector.hasTable(constraint.one_collection)) === false) {
+            logger.warn(`Ignoring ${constraint.many_collection}.${constraint.many_field}<->${constraint.one_collection}. Tables don't exist.`);
+            corruptedRelations.push(constraint.id);
+            continue;
+        }
+        const currentPrimaryKeyField = await inspector.primary(constraint.many_collection);
+        const relatedPrimaryKeyField = await inspector.primary(constraint.one_collection);
+        if (constraint.many_field === currentPrimaryKeyField) {
+            logger.warn(`Illegal relationship ${constraint.many_collection}.${constraint.many_field}<->${constraint.one_collection} encountered. Many field equals collections primary key.`);
+            corruptedRelations.push(constraint.id);
+            continue;
+        }
+        if (!currentPrimaryKeyField || !relatedPrimaryKeyField)
+            continue;
+        const rowsWithIllegalFKValues = await knex
+            .select(`main.${currentPrimaryKeyField}`)
+            .from({ main: constraint.many_collection })
+            .leftJoin({ related: constraint.one_collection }, `main.${constraint.many_field}`, `related.${relatedPrimaryKeyField}`)
+            .whereNull(`related.${relatedPrimaryKeyField}`);
+        if (rowsWithIllegalFKValues.length > 0) {
+            const ids = rowsWithIllegalFKValues.map((row) => row[currentPrimaryKeyField]);
+            try {
+                await knex(constraint.many_collection)
+                    .update({ [constraint.many_field]: null })
+                    .whereIn(currentPrimaryKeyField, ids);
+            }
+            catch (err) {
+                logger.error(`${constraint.many_collection}.${constraint.many_field} contains illegal foreign keys which couldn't be set to NULL. Please fix these references and rerun this migration to complete the upgrade.`);
+                if (ids.length < 25) {
+                    logger.error(`Items with illegal foreign keys: ${ids.join(', ')}`);
+                }
+                else {
+                    logger.error(`Items with illegal foreign keys: ${ids.slice(0, 25).join(', ')} and ${ids.length} others`);
+                }
+                throw 'Migration aborted';
+            }
+        }
+        // MySQL doesn't accept FKs from `int` to `int unsigned`. `knex` defaults `.increments()`
+        // to `unsigned`, but defaults `.integer()` to `int`. This means that created m2o fields
+        // have the wrong type. This step will force the m2o `int` field into `unsigned`, but only
+        // if both types are integers, and only if we go from `int` to `int unsigned`.
+        const columnInfo = await inspector.columnInfo(constraint.many_collection, constraint.many_field);
+        const relatedColumnInfo = await inspector.columnInfo(constraint.one_collection, relatedPrimaryKeyField);
+        try {
+            await knex.schema.alterTable(constraint.many_collection, (table) => {
+                if (columnInfo.data_type !== relatedColumnInfo.data_type &&
+                    columnInfo.data_type === 'int' &&
+                    relatedColumnInfo.data_type === 'int unsigned') {
+                    table.specificType(constraint.many_field, 'int unsigned').alter();
+                }
+                const indexName = getDefaultIndexName('foreign', constraint.many_collection, constraint.many_field);
+                const builder = table
+                    .foreign(constraint.many_field, indexName)
+                    .references(relatedPrimaryKeyField)
+                    .inTable(constraint.one_collection);
+                // Can't reliably have circular cascade
+                if (constraint.many_collection !== constraint.one_collection) {
+                    builder.onDelete('SET NULL');
+                }
+            });
+        }
+        catch (err) {
+            logger.warn(`Couldn't add foreign key constraint for ${constraint.many_collection}.${constraint.many_field}<->${constraint.one_collection}`);
+            logger.warn(err);
+        }
+    }
+    if (corruptedRelations.length > 0) {
+        logger.warn(`Encountered one or more corrupted relationships. Please check the following rows in "directus_relations": ${corruptedRelations.join(', ')}`);
+    }
+}
+export async function down(knex) {
+    const relations = await knex
+        .select('many_collection', 'many_field', 'one_collection')
+        .from('directus_relations');
+    for (const relation of relations) {
+        if (!relation.one_collection)
+            continue;
+        try {
+            await knex.schema.alterTable(relation.many_collection, (table) => {
+                table.dropForeign([relation.many_field]);
+            });
+        }
+        catch (err) {
+            logger.warn(`Couldn't drop foreign key constraint for ${relation.many_collection}.${relation.many_field}<->${relation.one_collection}`);
+            logger.warn(err);
+        }
+    }
+}

package/dist/database/migrations/20210519A-add-system-fk-triggers.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>;