@directus/api 13.2.0 → 14.0.1

package/dist/flows.js

@@ -33,7 +33,7 @@ const LAST_KEY = '$last';
 const ENV_KEY = '$env';
 class FlowManager {
     isLoaded = false;
-    operations = {};
+    operations = new Map();
     triggerHandlers = [];
     operationFlowHandlers = {};
     webhookFlowHandlers = {};
@@ -67,10 +67,10 @@ class FlowManager {
         messenger.publish('flows', { type: 'reload' });
     }
     addOperation(id, operation) {
-        this.operations[id] = operation;
+        this.operations.set(id, operation);
     }
-    clearOperations() {
-        this.operations = {};
+    removeOperation(id) {
+        this.operations.delete(id);
     }
     async runOperationFlow(id, data, context) {
         if (!(id in this.operationFlowHandlers)) {
@@ -305,11 +305,11 @@ class FlowManager {
         return undefined;
     }
     async executeOperation(operation, keyedData, context = {}) {
-        if (!(operation.type in this.operations)) {
+        if (!this.operations.has(operation.type)) {
             logger.warn(`Couldn't find operation ${operation.type}`);
             return { successor: null, status: 'unknown', data: null, options: null };
         }
-        const handler = this.operations[operation.type];
+        const handler = this.operations.get(operation.type);
         const options = applyOptionsData(operation.options, keyedData);
         try {
             let result = await handler(options, {

package/dist/middleware/respond.js

@@ -1,8 +1,10 @@
 import { parse as parseBytesConfiguration } from 'bytes';
+import { assign } from 'lodash-es';
 import { getCache, setCacheValue } from '../cache.js';
 import env from '../env.js';
 import logger from '../logger.js';
 import { ExportService } from '../services/import-export/index.js';
+import { VersionsService } from '../services/versions.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getCacheKey } from '../utils/get-cache-key.js';
@@ -17,6 +19,16 @@ export const respond = asyncHandler(async (req, res) => {
         const maxSize = parseBytesConfiguration(env['CACHE_VALUE_MAX_SIZE']);
         exceedsMaxSize = valueSize > maxSize;
     }
+    if (req.sanitizedQuery.version &&
+        req.collection &&
+        (req.singleton || req.params['pk']) &&
+        'data' in res.locals['payload']) {
+        const versionsService = new VersionsService({ accountability: req.accountability ?? null, schema: req.schema });
+        const saves = await versionsService.getVersionSaves(req.sanitizedQuery.version, req.collection, req.params['pk']);
+        if (saves) {
+            assign(res.locals['payload'].data, ...saves);
+        }
+    }
     if ((req.method.toLowerCase() === 'get' || req.originalUrl?.startsWith('/graphql')) &&
         env['CACHE_ENABLED'] === true &&
         cache &&

package/dist/server.js

@@ -10,9 +10,9 @@ import emitter from './emitter.js';
 import env from './env.js';
 import logger from './logger.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
+import { toBoolean } from './utils/to-boolean.js';
 import { createSubscriptionController, createWebSocketController, getSubscriptionController, getWebSocketController, } from './websocket/controllers/index.js';
 import { startWebSocketHandlers } from './websocket/handlers/index.js';
-import { toBoolean } from './utils/to-boolean.js';
 export let SERVER_ONLINE = true;
 export async function createServer() {
     const server = http.createServer(await createApp());
@@ -116,6 +116,7 @@ export async function startServer() {
     server
         .listen(port, host, () => {
         logger.info(`Server started at http://${host}:${port}`);
+        process.send?.('ready');
         emitter.emitAction('server.start', { server }, {
             database: getDatabase(),
             schema: null,

package/dist/services/assets.js

@@ -25,7 +25,7 @@ export class AssetsService {
     async getAsset(id, transformation, range) {
         const storage = await getStorage();
         const publicSettings = await this.knex
-            .select('project_logo', 'public_background', 'public_foreground')
+            .select('project_logo', 'public_background', 'public_foreground', 'public_favicon')
             .from('directus_settings')
             .first();
         const systemPublicKeys = Object.values(publicSettings || {});

package/dist/services/extensions.d.ts

@@ -0,0 +1,31 @@
+import type { ApiOutput, ExtensionSettings } from '@directus/extensions';
+import type { SchemaInspector } from '@directus/schema';
+import type { Accountability, DeepPartial, SchemaOverview } from '@directus/types';
+import type Keyv from 'keyv';
+import type { Knex } from 'knex';
+import type { Helpers } from '../database/helpers/index.js';
+import type { ExtensionManager } from '../extensions/manager.js';
+import type { AbstractServiceOptions } from '../types/index.js';
+import { ItemsService } from './items.js';
+import { PermissionsService } from './permissions.js';
+export declare class ExtensionsService {
+    knex: Knex;
+    permissionsService: PermissionsService;
+    schemaInspector: SchemaInspector;
+    accountability: Accountability | null;
+    schema: SchemaOverview;
+    extensionsItemService: ItemsService<ExtensionSettings>;
+    systemCache: Keyv<any>;
+    helpers: Helpers;
+    extensionsManager: ExtensionManager;
+    constructor(options: AbstractServiceOptions);
+    readAll(): Promise<ApiOutput[]>;
+    readOne(bundle: string | null, name: string): Promise<ApiOutput>;
+    updateOne(bundle: string | null, name: string, data: DeepPartial<ApiOutput>): Promise<void>;
+    private getKey;
+    /**
+     * Combine the settings stored in the database with the information available from the installed
+     * extensions into the standardized extensions api output
+     */
+    private stitch;
+}

package/dist/services/extensions.js

@@ -0,0 +1,136 @@
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
+import { createInspector } from '@directus/schema';
+import Joi from 'joi';
+import { omit, pick } from 'lodash-es';
+import { getCache } from '../cache.js';
+import { getHelpers } from '../database/helpers/index.js';
+import getDatabase, { getSchemaInspector } from '../database/index.js';
+import { getExtensionManager } from '../extensions/index.js';
+import { ItemsService } from './items.js';
+import { PermissionsService } from './permissions.js';
+export class ExtensionsService {
+    knex;
+    permissionsService;
+    schemaInspector;
+    accountability;
+    schema;
+    extensionsItemService;
+    systemCache;
+    helpers;
+    extensionsManager;
+    constructor(options) {
+        this.knex = options.knex || getDatabase();
+        this.permissionsService = new PermissionsService(options);
+        this.schemaInspector = options.knex ? createInspector(options.knex) : getSchemaInspector();
+        this.schema = options.schema;
+        this.accountability = options.accountability || null;
+        this.extensionsManager = getExtensionManager();
+        this.extensionsItemService = new ItemsService('directus_extensions', {
+            knex: this.knex,
+            schema: this.schema,
+            // No accountability here, as every other method is hardcoded to be admin only
+        });
+        this.systemCache = getCache().systemCache;
+        this.helpers = getHelpers(this.knex);
+    }
+    async readAll() {
+        if (this.accountability?.admin !== true) {
+            throw new ForbiddenError();
+        }
+        const installedExtensions = this.extensionsManager.getExtensions();
+        const configuredExtensions = await this.extensionsItemService.readByQuery({ limit: -1 });
+        return this.stitch(installedExtensions, configuredExtensions);
+    }
+    async readOne(bundle, name) {
+        if (this.accountability?.admin !== true) {
+            throw new ForbiddenError();
+        }
+        const key = this.getKey(bundle, name);
+        const schema = this.extensionsManager.getExtensions().find((extension) => extension.name === bundle ?? name);
+        const meta = await this.extensionsItemService.readOne(key);
+        const stitched = this.stitch(schema ? [schema] : [], [meta])[0];
+        if (stitched)
+            return stitched;
+        throw new ForbiddenError();
+    }
+    async updateOne(bundle, name, data) {
+        if (this.accountability?.admin !== true) {
+            throw new ForbiddenError();
+        }
+        const key = this.getKey(bundle, name);
+        const updateExtensionSchema = Joi.object({
+            meta: Joi.object({
+                enabled: Joi.boolean(),
+            }),
+        });
+        const { error } = updateExtensionSchema.validate(data);
+        if (error) {
+            throw new InvalidPayloadError({ reason: error.message });
+        }
+        if ('meta' in data && 'enabled' in data.meta) {
+            await this.knex('directus_extensions').update({ enabled: data.meta.enabled }).where({ name: key });
+            this.extensionsManager.reload();
+        }
+    }
+    getKey(bundle, name) {
+        return bundle ? `${bundle}/${name}` : name;
+    }
+    /**
+     * Combine the settings stored in the database with the information available from the installed
+     * extensions into the standardized extensions api output
+     */
+    stitch(installed, configured) {
+        /**
+         * On startup, the extensions manager will automatically create the rows for installed
+         * extensions that don't have configured settings yet, so there should always be equal or more
+         * settings rows than installed extensions.
+         */
+        return configured.map((meta) => {
+            let bundleName = null;
+            let name = meta.name;
+            if (name.includes('/')) {
+                const parts = name.split('/');
+                // NPM packages can have an optional organization scope in the format
+                // `@<org>/<package>`. This is limited to a single `/`.
+                //
+                // `foo` -> extension
+                // `foo/bar` -> bundle
+                // `@rijk/foo` -> extension
+                // `@rijk/foo/bar -> bundle
+                const hasOrg = parts.at(0).startsWith('@');
+                if (hasOrg && parts.length > 2) {
+                    name = parts.pop();
+                    bundleName = parts.join('/');
+                }
+                else if (hasOrg === false) {
+                    [bundleName, name] = parts;
+                }
+            }
+            let schema;
+            if (bundleName) {
+                const bundle = installed.find((extension) => extension.name === bundleName);
+                if (bundle && 'entries' in bundle) {
+                    const entry = bundle.entries.find((entry) => entry.name === name) ?? null;
+                    if (entry) {
+                        schema = {
+                            type: entry.type,
+                            local: bundle.local,
+                        };
+                    }
+                }
+                else {
+                    schema = null;
+                }
+            }
+            else {
+                schema = installed.find((extension) => extension.name === name) ?? null;
+            }
+            return {
+                name,
+                bundle: bundleName,
+                schema: schema ? pick(schema, 'type', 'local') : null,
+                meta: omit(meta, 'name'),
+            };
+        });
+    }
+}

package/dist/services/graphql/index.d.ts

@@ -1,4 +1,4 @@
-import type { DirectusError } from '@directus/errors';
+import { type DirectusError } from '@directus/errors';
 import type { Accountability, Filter, Query, SchemaOverview } from '@directus/types';
 import type { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLResolveInfo, SelectionNode } from 'graphql';
 import { GraphQLError, GraphQLSchema } from 'graphql';

package/dist/services/graphql/index.js

@@ -1,16 +1,14 @@
 import { Action, FUNCTIONS } from '@directus/constants';
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, ForbiddenError, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import { parseFilterFunctionPath } from '@directus/utils';
 import argon2 from 'argon2';
 import { GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, GraphQLUnionType, NoSchemaIntrospectionCustomRule, execute, specifiedRules, validate, } from 'graphql';
 import { GraphQLJSON, InputTypeComposer, ObjectTypeComposer, SchemaComposer, toInputObjectType } from 'graphql-compose';
-import { flatten, get, mapKeys, merge, omit, pick, set, transform, uniq } from 'lodash-es';
+import { assign, flatten, get, mapKeys, merge, omit, pick, set, transform, uniq } from 'lodash-es';
 import { clearSystemCache, getCache } from '../../cache.js';
 import { DEFAULT_AUTH_PROVIDER, GENERATE_SPECIAL } from '../../constants.js';
 import getDatabase from '../../database/index.js';
 import env from '../../env.js';
-import { ErrorCode, ForbiddenError, InvalidPayloadError } from '@directus/errors';
-import { getExtensionManager } from '../../extensions/index.js';
 import { generateHash } from '../../utils/generate-hash.js';
 import { getGraphQLType } from '../../utils/get-graphql-type.js';
 import { getMilliseconds } from '../../utils/get-milliseconds.js';
@@ -22,6 +20,7 @@ import { validateQuery } from '../../utils/validate-query.js';
 import { ActivityService } from '../activity.js';
 import { AuthenticationService } from '../authentication.js';
 import { CollectionsService } from '../collections.js';
+import { ExtensionsService } from '../extensions.js';
 import { FieldsService } from '../fields.js';
 import { FilesService } from '../files.js';
 import { RelationsService } from '../relations.js';
@@ -31,6 +30,7 @@ import { SpecificationService } from '../specifications.js';
 import { TFAService } from '../tfa.js';
 import { UsersService } from '../users.js';
 import { UtilsService } from '../utils.js';
+import { VersionsService } from '../versions.js';
 import { GraphQLExecutionError, GraphQLValidationError } from './errors/index.js';
 import { createSubscriptionGenerator } from './subscription.js';
 import { GraphQLBigInt } from './types/bigint.js';
@@ -54,6 +54,7 @@ const SYSTEM_DENY_LIST = [
     'directus_relations',
     'directus_migrations',
     'directus_sessions',
+    'directus_extensions',
 ];
 const READ_ONLY = ['directus_activity', 'directus_revisions'];
 export class GraphQLService {
@@ -842,6 +843,13 @@ export class GraphQLService {
                         },
                     };
                 }
+                else {
+                    resolver.args = {
+                        version: {
+                            type: GraphQLString,
+                        },
+                    };
+                }
                 ReadCollectionTypes[collection.collection].addResolver(resolver);
                 ReadCollectionTypes[collection.collection].addResolver({
                     name: `${collection.collection}_aggregated`,
@@ -877,6 +885,7 @@ export class GraphQLService {
                         type: ReadCollectionTypes[collection.collection],
                         args: {
                             id: new GraphQLNonNull(GraphQLID),
+                            version: GraphQLString,
                         },
                         resolve: async ({ info, context }) => {
                             const result = await self.resolveQuery(info);
@@ -1147,6 +1156,20 @@ export class GraphQLService {
             }
         }
         const result = await this.read(collection, query);
+        if (args['version']) {
+            const versionsService = new VersionsService({ accountability: this.accountability, schema: this.schema });
+            const saves = await versionsService.getVersionSaves(args['version'], collection, args['id']);
+            if (saves) {
+                if (this.schema.collections[collection].singleton) {
+                    return assign(result, ...saves);
+                }
+                else {
+                    if (result?.[0] === undefined)
+                        return null;
+                    return assign(result[0], ...saves);
+                }
+            }
+        }
         if (args['id']) {
             return result?.[0] || null;
         }
@@ -1597,26 +1620,6 @@ export class GraphQLService {
         }
         /** Globally available query */
         schemaComposer.Query.addFields({
-            extensions: {
-                type: schemaComposer.createObjectTC({
-                    name: 'extensions',
-                    fields: {
-                        interfaces: new GraphQLList(GraphQLString),
-                        displays: new GraphQLList(GraphQLString),
-                        layouts: new GraphQLList(GraphQLString),
-                        modules: new GraphQLList(GraphQLString),
-                    },
-                }),
-                resolve: async () => {
-                    const extensionManager = getExtensionManager();
-                    return {
-                        interfaces: extensionManager.getExtensionsList('interface'),
-                        displays: extensionManager.getExtensionsList('display'),
-                        layouts: extensionManager.getExtensionsList('layout'),
-                        modules: extensionManager.getExtensionsList('module'),
-                    };
-                },
-            },
             server_specs_oas: {
                 type: GraphQLJSON,
                 resolve: async () => {
@@ -1678,6 +1681,9 @@ export class GraphQLService {
         const Relation = schemaComposer.createObjectTC({
             name: 'directus_relations',
         });
+        const Extension = schemaComposer.createObjectTC({
+            name: 'directus_extensions',
+        });
         /**
          * Globally available mutations
          */
@@ -2361,6 +2367,63 @@ export class GraphQLService {
                     },
                 },
             });
+            Extension.addFields({
+                bundle: GraphQLString,
+                name: new GraphQLNonNull(GraphQLString),
+                schema: schemaComposer.createObjectTC({
+                    name: 'directus_extensions_schema',
+                    fields: {
+                        type: GraphQLString,
+                        local: GraphQLBoolean,
+                    },
+                }),
+                meta: schemaComposer.createObjectTC({
+                    name: 'directus_extensions_meta',
+                    fields: {
+                        enabled: GraphQLBoolean,
+                    },
+                }),
+            });
+            schemaComposer.Query.addFields({
+                extensions: {
+                    type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Extension.getType()))),
+                    resolve: async () => {
+                        const service = new ExtensionsService({
+                            accountability: this.accountability,
+                            schema: this.schema,
+                        });
+                        return await service.readAll();
+                    },
+                },
+            });
+            schemaComposer.Mutation.addFields({
+                update_extensions_item: {
+                    type: Extension,
+                    args: {
+                        bundle: GraphQLString,
+                        name: new GraphQLNonNull(GraphQLString),
+                        data: toInputObjectType(schemaComposer.createObjectTC({
+                            name: 'update_directus_extensions_input',
+                            fields: {
+                                meta: schemaComposer.createObjectTC({
+                                    name: 'update_directus_extensions_input_meta',
+                                    fields: {
+                                        enabled: GraphQLBoolean,
+                                    },
+                                }),
+                            },
+                        })),
+                    },
+                    resolve: async (_, args) => {
+                        const extensionsService = new ExtensionsService({
+                            accountability: this.accountability,
+                            schema: this.schema,
+                        });
+                        await extensionsService.updateOne(args['bundle'], args['name'], args['data']);
+                        return await extensionsService.readOne(args['bundle'], args['name']);
+                    },
+                },
+            });
         }
         if ('directus_users' in schema.read.collections) {
             schemaComposer.Query.addFields({

package/dist/services/index.d.ts

@@ -4,6 +4,7 @@ export * from './authentication.js';
 export * from './authorization.js';
 export * from './collections.js';
 export * from './dashboards.js';
+export * from './extensions.js';
 export * from './fields.js';
 export * from './files.js';
 export * from './flows.js';
@@ -31,5 +32,6 @@ export * from './tfa.js';
 export * from './translations.js';
 export * from './users.js';
 export * from './utils.js';
+export * from './versions.js';
 export * from './webhooks.js';
 export * from './websocket.js';

package/dist/services/index.js

@@ -4,6 +4,7 @@ export * from './authentication.js';
 export * from './authorization.js';
 export * from './collections.js';
 export * from './dashboards.js';
+export * from './extensions.js';
 export * from './fields.js';
 export * from './files.js';
 export * from './flows.js';
@@ -31,5 +32,6 @@ export * from './tfa.js';
 export * from './translations.js';
 export * from './users.js';
 export * from './utils.js';
+export * from './versions.js';
 export * from './webhooks.js';
 export * from './websocket.js';

package/dist/services/server.js

@@ -12,8 +12,8 @@ import { rateLimiter } from '../middleware/rate-limiter-ip.js';
 import { SERVER_ONLINE } from '../server.js';
 import { getStorage } from '../storage/index.js';
 import { version } from '../utils/package.js';
-import { SettingsService } from './settings.js';
 import { toBoolean } from '../utils/to-boolean.js';
+import { SettingsService } from './settings.js';
 export class ServerService {
     knex;
     accountability;
@@ -33,9 +33,11 @@ export class ServerService {
                 'project_descriptor',
                 'project_logo',
                 'project_color',
+                'default_appearance',
                 'default_language',
                 'public_foreground',
                 'public_background',
+                'public_favicon',
                 'public_note',
                 'custom_css',
             ],

package/dist/services/users.js

@@ -274,7 +274,9 @@ export class UsersService extends ItemsService {
         catch (err) {
             (opts || (opts = {})).preMutationError = err;
         }
+        // Manual constraint, see https://github.com/directus/directus/pull/19912
         await this.knex('directus_notifications').update({ sender: null }).whereIn('sender', keys);
+        await this.knex('directus_versions').update({ user_updated: null }).whereIn('user_updated', keys);
         await super.deleteMany(keys, opts);
         return keys;
     }

package/dist/services/versions.d.ts

@@ -0,0 +1,21 @@
+import type { Item, PrimaryKey, Query } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
+export declare class VersionsService extends ItemsService {
+    authorizationService: AuthorizationService;
+    constructor(options: AbstractServiceOptions);
+    private validateCreateData;
+    getMainItem(collection: string, item: PrimaryKey, query?: Query): Promise<Item>;
+    verifyHash(collection: string, item: PrimaryKey, hash: string): Promise<{
+        outdated: boolean;
+        mainHash: string;
+    }>;
+    getVersionSavesById(id: PrimaryKey): Promise<Partial<Item>[]>;
+    getVersionSaves(key: string, collection: string, item: string | undefined): Promise<Partial<Item>[] | null>;
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    save(key: PrimaryKey, data: Partial<Item>): Promise<Partial<Item>>;
+    promote(version: PrimaryKey, mainHash: string, fields?: string[]): Promise<import("../types/items.js").PrimaryKey>;
+}