@directus/api 13.1.1 → 14.0.0

package/dist/controllers/versions.js

@@ -0,0 +1,188 @@
+import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
+import express from 'express';
+import { assign } from 'lodash-es';
+import { respond } from '../middleware/respond.js';
+import useCollection from '../middleware/use-collection.js';
+import { validateBatch } from '../middleware/validate-batch.js';
+import { MetaService } from '../services/meta.js';
+import { VersionsService } from '../services/versions.js';
+import asyncHandler from '../utils/async-handler.js';
+import { sanitizeQuery } from '../utils/sanitize-query.js';
+const router = express.Router();
+router.use(useCollection('directus_versions'));
+router.post('/', asyncHandler(async (req, res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const savedKeys = [];
+    if (Array.isArray(req.body)) {
+        const keys = await service.createMany(req.body);
+        savedKeys.push(...keys);
+    }
+    else {
+        const primaryKey = await service.createOne(req.body);
+        savedKeys.push(primaryKey);
+    }
+    try {
+        if (Array.isArray(req.body)) {
+            const records = await service.readMany(savedKeys, req.sanitizedQuery);
+            res.locals['payload'] = { data: records };
+        }
+        else {
+            const record = await service.readOne(savedKeys[0], req.sanitizedQuery);
+            res.locals['payload'] = { data: record };
+        }
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+const readHandler = asyncHandler(async (req, res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let result;
+    if (req.singleton) {
+        result = await service.readSingleton(req.sanitizedQuery);
+    }
+    else if (req.body.keys) {
+        result = await service.readMany(req.body.keys, req.sanitizedQuery);
+    }
+    else {
+        result = await service.readByQuery(req.sanitizedQuery);
+    }
+    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+    res.locals['payload'] = { data: result, meta };
+    return next();
+});
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+router.get('/:pk', asyncHandler(async (req, res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const record = await service.readOne(req.params['pk'], req.sanitizedQuery);
+    res.locals['payload'] = { data: record || null };
+    return next();
+}), respond);
+router.patch('/', validateBatch('update'), asyncHandler(async (req, res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let keys = [];
+    if (Array.isArray(req.body)) {
+        keys = await service.updateBatch(req.body);
+    }
+    else if (req.body.keys) {
+        keys = await service.updateMany(req.body.keys, req.body.data);
+    }
+    else {
+        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+        keys = await service.updateByQuery(sanitizedQuery, req.body.data);
+    }
+    try {
+        const result = await service.readMany(keys, req.sanitizedQuery);
+        res.locals['payload'] = { data: result || null };
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.patch('/:pk', asyncHandler(async (req, res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const primaryKey = await service.updateOne(req.params['pk'], req.body);
+    try {
+        const record = await service.readOne(primaryKey, req.sanitizedQuery);
+        res.locals['payload'] = { data: record || null };
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
+router.delete('/', validateBatch('delete'), asyncHandler(async (req, _res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    if (Array.isArray(req.body)) {
+        await service.deleteMany(req.body);
+    }
+    else if (req.body.keys) {
+        await service.deleteMany(req.body.keys);
+    }
+    else {
+        const sanitizedQuery = sanitizeQuery(req.body.query, req.accountability);
+        await service.deleteByQuery(sanitizedQuery);
+    }
+    return next();
+}), respond);
+router.delete('/:pk', asyncHandler(async (req, _res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.deleteOne(req.params['pk']);
+    return next();
+}), respond);
+router.get('/:pk/compare', asyncHandler(async (req, res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const version = await service.readOne(req.params['pk']);
+    const { outdated, mainHash } = await service.verifyHash(version['collection'], version['item'], version['hash']);
+    const saves = await service.getVersionSavesById(version['id']);
+    const current = assign({}, ...saves);
+    const main = await service.getMainItem(version['collection'], version['item']);
+    res.locals['payload'] = { data: { outdated, mainHash, current, main } };
+    return next();
+}), respond);
+router.post('/:pk/save', asyncHandler(async (req, res, next) => {
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const version = await service.readOne(req.params['pk']);
+    const mainItem = await service.getMainItem(version['collection'], version['item']);
+    await service.save(req.params['pk'], req.body);
+    const saves = await service.getVersionSavesById(req.params['pk']);
+    const result = assign(mainItem, ...saves);
+    res.locals['payload'] = { data: result || null };
+    return next();
+}), respond);
+router.post('/:pk/promote', asyncHandler(async (req, res, next) => {
+    if (typeof req.body.mainHash !== 'string') {
+        throw new InvalidPayloadError({ reason: `"mainHash" field is required` });
+    }
+    const service = new VersionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const updatedItemKey = await service.promote(req.params['pk'], req.body.mainHash, req.body?.['fields']);
+    res.locals['payload'] = { data: updatedItemKey || null };
+    return next();
+}), respond);
+export default router;

package/dist/controllers/webhooks.js

@@ -1,6 +1,6 @@
 import { isDirectusError } from '@directus/errors';
 import express from 'express';
-import { ErrorCode } from '../errors/index.js';
+import { ErrorCode } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';

package/dist/database/errors/dialects/mssql.js

@@ -1,4 +1,4 @@
-import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '../../../errors/index.js';
+import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '@directus/errors';
 import getDatabase from '../../index.js';
 var MSSQLErrorCodes;
 (function (MSSQLErrorCodes) {

package/dist/database/errors/dialects/mysql.js

@@ -1,4 +1,4 @@
-import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '../../../errors/index.js';
+import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '@directus/errors';
 var MySQLErrorCodes;
 (function (MySQLErrorCodes) {
     MySQLErrorCodes["UNIQUE_VIOLATION"] = "ER_DUP_ENTRY";

package/dist/database/errors/dialects/oracle.js

@@ -1,4 +1,4 @@
-import { ContainsNullValuesError } from '../../../errors/index.js';
+import { ContainsNullValuesError } from '@directus/errors';
 var OracleErrorCodes;
 (function (OracleErrorCodes) {
     OracleErrorCodes[OracleErrorCodes["CONTAINS_NULL_VALUES"] = 2296] = "CONTAINS_NULL_VALUES";

package/dist/database/errors/dialects/postgres.js

@@ -1,4 +1,4 @@
-import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '../../../errors/index.js';
+import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '@directus/errors';
 var PostgresErrorCodes;
 (function (PostgresErrorCodes) {
     PostgresErrorCodes["FOREIGN_KEY_VIOLATION"] = "23503";

package/dist/database/errors/dialects/sqlite.js

@@ -1,4 +1,4 @@
-import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, } from '../../../errors/index.js';
+import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, } from '@directus/errors';
 // NOTE:
 // - Sqlite doesn't have varchar with length support, so no ValueTooLongError
 // - Sqlite doesn't have a max range for numbers, so no ValueOutOfRangeError

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

@@ -1,4 +1,4 @@
-import { getDatabaseVersion } from '../../../../database/index.js';
+import { getDatabaseVersion } from '../../../index.js';
 import { SchemaHelper } from '../types.js';
 export class SchemaHelperMySQL extends SchemaHelper {
     applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {

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

@@ -2,8 +2,11 @@ import type { Knex } from 'knex';
 import { AutoSequenceHelper } from '../types.js';
 export declare class AutoIncrementHelperPostgres extends AutoSequenceHelper {
     /**
-     * Resets the auto increment sequence for a table based on the max value of the PK column.
-     * The sequence name of determined using a sub query.
+     * Resets the auto increment sequence based on the max value of the PK column.
+     * The sequence name is determined using a sub query.
+     *
+     * The table name value for getting the sequence name needs to be escaped explicitly,
+     * otherwise PostgreSQL would throw an error for capitalized table names saying "relation x does not exist".
      */
     resetAutoIncrementSequence(table: string, column: string): Promise<Knex.Raw | void>;
 }

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

@@ -1,10 +1,13 @@
 import { AutoSequenceHelper } from '../types.js';
 export class AutoIncrementHelperPostgres extends AutoSequenceHelper {
     /**
-     * Resets the auto increment sequence for a table based on the max value of the PK column.
-     * The sequence name of determined using a sub query.
+     * Resets the auto increment sequence based on the max value of the PK column.
+     * The sequence name is determined using a sub query.
+     *
+     * The table name value for getting the sequence name needs to be escaped explicitly,
+     * otherwise PostgreSQL would throw an error for capitalized table names saying "relation x does not exist".
      */
     async resetAutoIncrementSequence(table, column) {
-        return await this.knex.raw(`WITH sequence_infos AS (SELECT pg_get_serial_sequence('${table}', '${column}') AS seq_name, MAX(${column}) as max_val FROM ${table}) SELECT SETVAL(seq_name, max_val) FROM sequence_infos;`);
+        return await this.knex.raw(`WITH sequence_infos AS (SELECT pg_get_serial_sequence(?, ?) AS seq_name, MAX(??) as max_val FROM ??) SELECT SETVAL(seq_name, max_val) FROM sequence_infos;`, [`"${table}"`, column, column, table]);
     }
 }

package/dist/database/migrations/20230823A-add-content-versioning.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/20230823A-add-content-versioning.js

@@ -0,0 +1,36 @@
+export async function up(knex) {
+    await knex.schema.createTable('directus_versions', (table) => {
+        table.uuid('id').primary().notNullable();
+        table.string('key', 64).notNullable();
+        table.string('name');
+        table
+            .string('collection', 64)
+            .notNullable()
+            .references('collection')
+            .inTable('directus_collections')
+            .onDelete('CASCADE');
+        table.string('item').notNullable();
+        // Hash is managed on API side
+        table.string('hash');
+        table.timestamp('date_created').defaultTo(knex.fn.now());
+        table.timestamp('date_updated').defaultTo(knex.fn.now());
+        table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
+        // Cannot have two constraints from/to the same table, handled on API side
+        table.uuid('user_updated').references('id').inTable('directus_users');
+    });
+    await knex.schema.alterTable('directus_collections', (table) => {
+        table.boolean('versioning').notNullable().defaultTo(false);
+    });
+    await knex.schema.alterTable('directus_revisions', (table) => {
+        table.uuid('version').references('id').inTable('directus_versions').onDelete('CASCADE');
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_collections', (table) => {
+        table.dropColumn('versioning');
+    });
+    await knex.schema.alterTable('directus_revisions', (table) => {
+        table.dropColumn('version');
+    });
+    await knex.schema.dropTable('directus_versions');
+}

package/dist/database/migrations/20230927A-themes.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/20230927A-themes.js

@@ -0,0 +1,49 @@
+export async function up(knex) {
+    /**
+     * Knex doesn't support setting defaults to null (you'll end up with `NULL::character varying`),
+     * so we'll have to create a new column, copy over the relevant bits, and remove the old
+     */
+    await knex.schema.alterTable('directus_users', (table) => {
+        table.string('appearance');
+    });
+    await knex('directus_users').update({ appearance: 'dark' }).where({ theme: 'dark' });
+    await knex('directus_users').update({ appearance: 'light' }).where({ theme: 'light' });
+    await knex.schema.alterTable('directus_users', (table) => {
+        table.dropColumn('theme');
+        table.string('theme_dark');
+        table.string('theme_light');
+        table.json('theme_light_overrides');
+        table.json('theme_dark_overrides');
+    });
+    await knex('directus_settings').update({ project_color: '#6644ff' }).whereNull('project_color');
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.string('project_color').defaultTo('#6644FF').notNullable().alter();
+        table.uuid('public_favicon').references('directus_files.id');
+        table.string('default_appearance').defaultTo('auto').notNullable();
+        table.string('default_theme_light');
+        table.json('theme_light_overrides');
+        table.string('default_theme_dark');
+        table.json('theme_dark_overrides');
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_users', (table) => {
+        table.renameColumn('appearance', 'theme');
+    });
+    await knex.schema.alterTable('directus_users', (table) => {
+        table.string('theme').defaultTo('auto').alter();
+        table.dropColumn('theme_dark');
+        table.dropColumn('theme_light');
+        table.dropColumn('theme_light_overrides');
+        table.dropColumn('theme_dark_overrides');
+    });
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.string('project_color').defaultTo(null).nullable().alter();
+        table.dropColumn('public_favicon');
+        table.dropColumn('default_appearance');
+        table.dropColumn('default_theme_light');
+        table.dropColumn('theme_light_overrides');
+        table.dropColumn('default_theme_dark');
+        table.dropColumn('theme_dark_overrides');
+    });
+}

package/dist/database/migrations/20231009A-update-csv-fields-to-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/20231009A-update-csv-fields-to-text.js

@@ -0,0 +1,44 @@
+import { getHelpers } from '../helpers/index.js';
+import { createInspector } from '@directus/schema';
+export async function up(knex) {
+    const inspector = createInspector(knex);
+    const helper = getHelpers(knex).schema;
+    const csvFields = await knex.select('collection', 'field').from('directus_fields').where('special', '=', 'cast-csv');
+    const updates = [];
+    for (const { collection, field } of csvFields) {
+        updates.push(inspector.columnInfo(collection, field).then((column) => {
+            if (column.data_type === 'text')
+                return;
+            return helper.changeToType(collection, field, 'text', {
+                default: column.default_value,
+                nullable: column.is_nullable,
+            });
+        }));
+    }
+    return checkPromises(updates);
+}
+export async function down(knex) {
+    const inspector = createInspector(knex);
+    const helper = getHelpers(knex).schema;
+    const csvFields = await knex.select('collection', 'field').from('directus_fields').where('special', '=', 'cast-csv');
+    const updates = [];
+    for (const { collection, field } of csvFields) {
+        updates.push(inspector.columnInfo(collection, field).then((column) => {
+            return helper.changeToType(collection, field, 'string', {
+                default: column.default_value,
+                nullable: column.is_nullable,
+            });
+        }));
+    }
+    return checkPromises(updates);
+}
+async function checkPromises(promises) {
+    const result = await Promise.allSettled(promises);
+    const errors = result.filter(isRejectedPromise).map((promise) => promise.reason);
+    if (errors.length > 0) {
+        throw new Error(errors.toString());
+    }
+}
+function isRejectedPromise(promise) {
+    return promise.status === 'rejected';
+}

package/dist/database/migrations/20231009B-update-panel-options.d.ts

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

package/dist/database/migrations/20231009B-update-panel-options.js

@@ -0,0 +1,77 @@
+export async function up(knex) {
+    const panels = await knex('directus_panels').where('type', '=', 'metric').select();
+    const updates = [];
+    for (const panel of panels) {
+        let options = panel.options;
+        // Check if the options are stringified and parse them
+        const wasStringified = typeof options === 'string';
+        if (wasStringified) {
+            options = JSON.parse(options);
+        }
+        // Not expected, just to be on the safe side
+        if (!options)
+            continue;
+        let needsUpdate = false;
+        // Check and update abbreviate -> notation
+        if (options.abbreviate === true) {
+            options.notation = 'compact';
+            delete options.abbreviate;
+            needsUpdate = true;
+        }
+        // Check and update decimals -> minimumFractionDigits and maximumFractionDigits
+        if (typeof options.decimals === 'number') {
+            options.minimumFractionDigits = options.decimals;
+            options.maximumFractionDigits = options.decimals;
+            delete options.decimals;
+            needsUpdate = true;
+        }
+        // Update the row with modified options if necessary
+        if (needsUpdate) {
+            // Convert the options back to string if they were stringified initially
+            if (wasStringified) {
+                options = JSON.stringify(options);
+            }
+            updates.push(knex('directus_panels').update({ options }).where('id', panel.id));
+        }
+    }
+    return Promise.all(updates);
+}
+export async function down(knex) {
+    const panels = await knex('directus_panels').where('type', '=', 'metric').select();
+    const updates = [];
+    for (const panel of panels) {
+        let options = panel.options;
+        // Check if the options are stringified and parse them
+        const wasStringified = typeof options === 'string';
+        if (wasStringified) {
+            options = JSON.parse(options);
+        }
+        // Not expected, just to be on the safe side
+        if (!options)
+            continue;
+        let needsUpdate = false;
+        // Revert notation -> abbreviate
+        if (options.notation === 'compact') {
+            options.abbreviate = true;
+            delete options.notation;
+            needsUpdate = true;
+        }
+        // Revert minimumFractionDigits and maximumFractionDigits -> decimals
+        if (typeof options.minimumFractionDigits === 'number' &&
+            options.minimumFractionDigits === options.maximumFractionDigits) {
+            options.decimals = options.minimumFractionDigits;
+            delete options.minimumFractionDigits;
+            delete options.maximumFractionDigits;
+            needsUpdate = true;
+        }
+        // Update the row with reverted options if necessary
+        if (needsUpdate) {
+            // Convert the options back to string if they were stringified initially
+            if (wasStringified) {
+                options = JSON.stringify(options);
+            }
+            updates.push(knex('directus_panels').update({ options }).where('id', panel.id));
+        }
+    }
+    return Promise.all(updates);
+}

package/dist/database/migrations/20231010A-add-extensions.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/20231010A-add-extensions.js

@@ -0,0 +1,9 @@
+export async function up(knex) {
+    await knex.schema.createTable('directus_extensions', (table) => {
+        table.string('name').primary().notNullable();
+        table.boolean('enabled').defaultTo(true).notNullable();
+    });
+}
+export async function down(knex) {
+    await knex.schema.dropTable('directus_extensions');
+}

package/dist/database/run-ast.js

@@ -1,6 +1,6 @@
 import { toArray } from '@directus/utils';
 import { clone, cloneDeep, isNil, merge, pick, uniq } from 'lodash-es';
-import { getHelpers } from '../database/helpers/index.js';
+import { getHelpers } from './helpers/index.js';
 import env from '../env.js';
 import { PayloadService } from '../services/payload.js';
 import { applyFunctionToColumnName } from '../utils/apply-function-to-column-name.js';
@@ -164,7 +164,7 @@ async function getDBQuery(schema, knex, table, fieldNodes, query) {
     const innerQuerySortRecords = [];
     let hasMultiRelationalSort;
     if (queryCopy.sort) {
-        const sortResult = applySort(knex, schema, dbQuery, queryCopy.sort, table, aliasMap, true);
+        const sortResult = applySort(knex, schema, dbQuery, queryCopy, table, aliasMap, true);
         if (sortResult) {
             sortRecords = sortResult.sortRecords;
             hasMultiRelationalSort = sortResult.hasMultiRelationalSort;

package/dist/database/seeds/run.js

@@ -30,7 +30,7 @@ export default async function runSeed(database) {
                     column = tableBuilder.increments();
                 }
                 else if (columnInfo.type === 'csv') {
-                    column = tableBuilder.string(columnName);
+                    column = tableBuilder.text(columnName);
                 }
                 else if (columnInfo.type === 'hash') {
                     column = tableBuilder.string(columnName, 255);

package/dist/database/system-data/collections/collections.yaml

@@ -95,3 +95,9 @@ data:
 
   - collection: directus_translations
     note: $t:directus_collection.directus_translations
+
+  - collection: directus_versions
+    note: $t:directus_collection.directus_versions
+
+  - collection: directus_extensions
+    note: $t:directus_collection.directus_extensions

package/dist/database/system-data/fields/activity.yaml

@@ -13,15 +13,15 @@ fields:
       choices:
         - text: $t:field_options.directus_activity.create
           value: create
-          foreground: 'var(--primary)'
-          background: 'var(--primary-25)'
+          foreground: 'var(--theme--primary)'
+          background: 'var(--theme--primary-subdued)'
         - text: $t:field_options.directus_activity.update
           value: update
           foreground: 'var(--blue)'
           background: 'var(--blue-25)'
         - text: $t:field_options.directus_activity.delete
           value: delete
-          foreground: 'var(--danger)'
+          foreground: 'var(--theme--danger)'
           background: 'var(--danger-25)'
         - text: $t:field_options.directus_activity.login
           value: login
@@ -51,7 +51,7 @@ fields:
   - field: comment
     display: formatted-value
     display_options:
-      color: 'var(--foreground-subdued)'
+      color: 'var(--theme--foreground-subdued)'
     width: half
 
   - field: user_agent

package/dist/database/system-data/fields/collections.yaml

@@ -114,8 +114,27 @@ fields:
     interface: system-display-template
     options:
       collectionField: collection
+      injectVersionField: true
     width: full
 
+  - field: content_versioning_divider
+    special:
+      - alias
+      - no-data
+    interface: presentation-divider
+    options:
+      icon: published_with_changes
+      title: $t:field_options.directus_collections.content_versioning_divider
+    width: full
+
+  - field: versioning
+    interface: boolean
+    special:
+      - cast-boolean
+    options:
+      label: $t:field_options.directus_collections.enable_versioning
+    width: half
+
   - field: archive_divider
     special:
       - alias

package/dist/database/system-data/fields/extensions.yaml

@@ -0,0 +1,10 @@
+table: directus_extensions
+
+fields:
+  - collection: directus_extensions
+    field: name
+
+  - collection: directus_extensions
+    field: enabled
+    special:
+      - cast-boolean

package/dist/database/system-data/fields/revisions.yaml

@@ -25,3 +25,6 @@ fields:
 
   - field: parent
     width: half
+
+  - field: version
+    width: half