@directus/api 13.2.0 → 14.0.1

package/dist/__utils__/snapshots.js

@@ -13,6 +13,7 @@ export const snapshotBeforeCreateCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {
@@ -86,6 +87,7 @@ export const snapshotCreateCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {
@@ -105,6 +107,7 @@ export const snapshotCreateCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {
@@ -124,6 +127,7 @@ export const snapshotCreateCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {
@@ -287,6 +291,7 @@ export const snapshotCreateCollectionNotNested = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {
@@ -306,6 +311,7 @@ export const snapshotCreateCollectionNotNested = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {
@@ -424,6 +430,7 @@ export const snapshotBeforeDeleteCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {
@@ -443,6 +450,7 @@ export const snapshotBeforeDeleteCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {
@@ -462,6 +470,7 @@ export const snapshotBeforeDeleteCollection = {
                 item_duplication_fields: null,
                 note: null,
                 singleton: false,
+                versioning: false,
                 translations: {},
             },
             schema: {

package/dist/app.js

@@ -35,6 +35,7 @@ import sharesRouter from './controllers/shares.js';
 import translationsRouter from './controllers/translations.js';
 import usersRouter from './controllers/users.js';
 import utilsRouter from './controllers/utils.js';
+import versionsRouter from './controllers/versions.js';
 import webhooksRouter from './controllers/webhooks.js';
 import { isInstalled, validateDatabaseConnection, validateDatabaseExtensions, validateMigrations, } from './database/index.js';
 import emitter from './emitter.js';
@@ -222,6 +223,7 @@ export default async function createApp() {
     app.use('/shares', sharesRouter);
     app.use('/users', usersRouter);
     app.use('/utils', utilsRouter);
+    app.use('/versions', versionsRouter);
     app.use('/webhooks', webhooksRouter);
     // Register custom endpoints
     await emitter.emitInit('routes.custom.before', { app });

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 import { Command, Option } from 'commander';
 import emitter from '../emitter.js';
-import { getExtensionManager } from '../extensions/index.js';
 import { startServer } from '../server.js';
+import * as pkg from '../utils/package.js';
 import bootstrap from './commands/bootstrap/index.js';
 import count from './commands/count/index.js';
 import dbInstall from './commands/database/install.js';
@@ -14,11 +14,10 @@ import keyGenerate from './commands/security/key.js';
 import secretGenerate from './commands/security/secret.js';
 import usersCreate from './commands/users/create.js';
 import usersPasswd from './commands/users/passwd.js';
-import * as pkg from '../utils/package.js';
+import { loadExtensions } from './load-extensions.js';
 export async function createCli() {
     const program = new Command();
-    const extensionManager = getExtensionManager();
-    await extensionManager.initialize({ schedule: false, watch: false });
+    await loadExtensions();
     await emitter.emitInit('cli.before', { program });
     program.name('directus').usage('[command] [options]');
     program.version(pkg.version, '-v, --version');

package/dist/cli/load-extensions.d.ts

@@ -0,0 +1 @@
+export declare const loadExtensions: () => Promise<void>;

package/dist/cli/load-extensions.js

@@ -0,0 +1,19 @@
+import { isInstalled, validateMigrations } from '../database/index.js';
+import { getEnv } from '../env.js';
+import { getExtensionManager } from '../extensions/index.js';
+import logger from '../logger.js';
+export const loadExtensions = async () => {
+    const env = getEnv();
+    if (!('DB_CLIENT' in env))
+        return;
+    const installed = await isInstalled();
+    if (!installed)
+        return;
+    const migrationsValid = await validateMigrations();
+    if (!migrationsValid) {
+        logger.info('Skipping CLI extensions initialization due to outstanding migrations.');
+        return;
+    }
+    const extensionManager = getExtensionManager();
+    await extensionManager.initialize({ schedule: false, watch: false });
+};

package/dist/controllers/extensions.js

@@ -1,28 +1,37 @@
-import { EXTENSION_TYPES } from '@directus/extensions';
-import { depluralize, isIn } from '@directus/utils';
-import { Router } from 'express';
+import { ForbiddenError, RouteNotFoundError } from '@directus/errors';
+import express from 'express';
 import env from '../env.js';
-import { RouteNotFoundError } from '@directus/errors';
 import { getExtensionManager } from '../extensions/index.js';
 import { respond } from '../middleware/respond.js';
+import useCollection from '../middleware/use-collection.js';
+import { ExtensionsService } from '../services/extensions.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
-const router = Router();
-router.get('/:type?', asyncHandler(async (req, res, next) => {
-    let type = undefined;
-    if (req.params['type']) {
-        const singularType = depluralize(req.params['type']);
-        if (!isIn(singularType, EXTENSION_TYPES)) {
-            throw new RouteNotFoundError({ path: req.path });
-        }
-        type = singularType;
+const router = express.Router();
+router.use(useCollection('directus_extensions'));
+router.get('/', asyncHandler(async (req, res, next) => {
+    const service = new ExtensionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const extensions = await service.readAll();
+    res.locals['payload'] = { data: extensions || null };
+    return next();
+}), respond);
+router.patch('/:bundleOrName/:name?', asyncHandler(async (req, res, next) => {
+    const service = new ExtensionsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const bundle = req.params['name'] ? req.params['bundleOrName'] : null;
+    const name = req.params['name'] ? req.params['name'] : req.params['bundleOrName'];
+    if (bundle === undefined || !name) {
+        throw new ForbiddenError();
     }
-    const extensionManager = getExtensionManager();
-    const extensions = extensionManager.getExtensionsList(type);
-    res.locals['payload'] = {
-        data: extensions,
-    };
+    await service.updateOne(bundle, name, req.body);
+    const updated = await service.readOne(bundle, name);
+    res.locals['payload'] = { data: updated || null };
     return next();
 }), respond);
 router.get('/sources/:chunk', asyncHandler(async (req, res) => {
@@ -30,7 +39,7 @@ router.get('/sources/:chunk', asyncHandler(async (req, res) => {
     const extensionManager = getExtensionManager();
     let source;
     if (chunk === 'index.js') {
-        source = extensionManager.getAppExtensions();
+        source = extensionManager.getAppExtensionsBundle();
     }
     else {
         source = extensionManager.getAppExtensionChunk(chunk);

package/dist/controllers/versions.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

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/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/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

@@ -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/system-data/app-access-permissions/app-access-permissions.yaml

@@ -99,7 +99,11 @@
     - preferences_divider
     - avatar
     - language
-    - theme
+    - appearance
+    - theme_light
+    - theme_dark
+    - theme_light_overrides
+    - theme_dark_overrides
     - tfa_secret
     - status
     - role

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