@directus/api 33.3.1 → 34.0.0

package/dist/services/authentication.js

@@ -42,11 +42,25 @@ export class AuthenticationService {
         const STALL_TIME = env['LOGIN_STALL_TIME'];
         const timeStart = performance.now();
         const provider = getAuthProvider(providerName);
+        const emitStatus = (status, loginPayload, loginUser, error) => {
+            emitter.emitAction('auth.login', {
+                payload: loginPayload,
+                status,
+                user: loginUser?.id,
+                provider: providerName,
+                error,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        };
         let userId;
         try {
             userId = await provider.getUserID(cloneDeep(payload));
         }
         catch (err) {
+            emitStatus('fail', payload, undefined, err);
             await stall(STALL_TIME, timeStart);
             throw err;
         }
@@ -64,22 +78,11 @@ export class AuthenticationService {
             schema: this.schema,
             accountability: this.accountability,
         });
-        const emitStatus = (status) => {
-            emitter.emitAction('auth.login', {
-                payload: updatedPayload,
-                status,
-                user: user?.id,
-                provider: providerName,
-            }, {
-                database: this.knex,
-                schema: this.schema,
-                accountability: this.accountability,
-            });
-        };
         if (user?.status !== 'active' || user?.provider !== providerName) {
-            emitStatus('fail');
+            const loginError = new InvalidCredentialsError();
+            emitStatus('fail', updatedPayload, user, loginError);
             await stall(STALL_TIME, timeStart);
-            throw new InvalidCredentialsError();
+            throw loginError;
         }
         const settingsService = new SettingsService({
             knex: this.knex,
@@ -130,23 +133,25 @@ export class AuthenticationService {
         try {
             await provider.login(clone(user), cloneDeep(updatedPayload));
         }
-        catch (e) {
-            emitStatus('fail');
+        catch (err) {
+            emitStatus('fail', updatedPayload, user, err);
             await stall(STALL_TIME, timeStart);
-            throw e;
+            throw err;
         }
         if (user.tfa_secret && !options?.otp) {
-            emitStatus('fail');
+            const loginError = new InvalidOtpError();
+            emitStatus('fail', updatedPayload, user, loginError);
             await stall(STALL_TIME, timeStart);
-            throw new InvalidOtpError();
+            throw loginError;
         }
         if (user.tfa_secret && options?.otp) {
             const tfaService = new TFAService({ knex: this.knex, schema: this.schema });
             const otpValid = await tfaService.verifyOTP(user.id, options?.otp);
             if (otpValid === false) {
-                emitStatus('fail');
+                const loginError = new InvalidOtpError();
+                emitStatus('fail', updatedPayload, user, loginError);
                 await stall(STALL_TIME, timeStart);
-                throw new InvalidOtpError();
+                throw loginError;
             }
         }
         const roles = await fetchRolesTree(user.role, { knex: this.knex });
@@ -214,7 +219,7 @@ export class AuthenticationService {
             });
         }
         await this.knex('directus_users').update({ last_access: new Date() }).where({ id: user.id });
-        emitStatus('success');
+        emitStatus('success', updatedPayload, user);
         if (allowedAttempts !== null) {
             await loginAttemptsLimiter.set(user.id, 0, 0);
         }

package/dist/services/collections.js

@@ -52,6 +52,7 @@ export class CollectionsService {
         if (payload.collection.startsWith('directus_')) {
             throw new InvalidPayloadError({ reason: `Collections can't start with "directus_"` });
         }
+        payload.collection = await this.helpers.schema.parseCollectionName(payload.collection);
         const nestedActionEvents = [];
         try {
             const existingCollections = [

package/dist/services/deployment-projects.d.ts

@@ -1,20 +1,49 @@
-import type { AbstractServiceOptions, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, PrimaryKey, Project as ProviderProject, ProviderType } from '@directus/types';
 import { ItemsService } from './items.js';
 export interface DeploymentProject {
     id: string;
     deployment: string;
     external_id: string;
     name: string;
+    url: string | null;
+    framework: string | null;
+    deployable: boolean;
     date_created: string;
     user_created: string;
 }
 export declare class DeploymentProjectsService extends ItemsService<DeploymentProject> {
     constructor(options: AbstractServiceOptions);
+    /**
+     * Find a project by its provider-side external ID. Returns null if not tracked.
+     */
+    readByExternalId(externalId: string): Promise<DeploymentProject | null>;
+    /**
+     * List provider projects merged with DB selection, syncing metadata.
+     */
+    listWithSync(deploymentId: string, providerProjects: ProviderProject[]): Promise<{
+        id: string | null;
+        external_id: string;
+        name: string;
+        deployable: boolean;
+        framework: string | undefined;
+    }[]>;
+    /**
+     * Validate that all projects to create are deployable.
+     */
+    validateDeployable(provider: ProviderType, projectsToCreate: {
+        external_id: string;
+        name: string;
+    }[]): Promise<void>;
     /**
      * Update project selection (create/delete)
      */
-    updateSelection(deploymentId: string, create: {
+    updateSelection(provider: ProviderType, create: {
         external_id: string;
         name: string;
     }[], deleteIds: PrimaryKey[]): Promise<DeploymentProject[]>;
+    /**
+     * Read deployment config by provider (null accountability for internal use).
+     */
+    private readConfig;
+    private createDriver;
 }

package/dist/services/deployment-projects.js

@@ -1,15 +1,92 @@
+import { InvalidPayloadError } from '@directus/errors';
 import getDatabase from '../database/index.js';
+import { getDeploymentDriver } from '../deployment.js';
+import { parseValue } from '../utils/parse-value.js';
 import { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
 export class DeploymentProjectsService extends ItemsService {
     constructor(options) {
         super('directus_deployment_projects', options);
     }
+    /**
+     * Find a project by its provider-side external ID. Returns null if not tracked.
+     */
+    async readByExternalId(externalId) {
+        const results = await this.readByQuery({
+            filter: { external_id: { _eq: externalId } },
+            limit: 1,
+        });
+        return results?.[0] ?? null;
+    }
+    /**
+     * List provider projects merged with DB selection, syncing metadata.
+     */
+    async listWithSync(deploymentId, providerProjects) {
+        const selectedProjects = await this.readByQuery({
+            filter: { deployment: { _eq: deploymentId } },
+            limit: -1,
+        });
+        const selectedMap = new Map(selectedProjects.map((p) => [p.external_id, p]));
+        // Sync name and deployable
+        const toUpdate = selectedProjects
+            .map((dbProject) => {
+            const providerProject = providerProjects.find((p) => p.id === dbProject.external_id);
+            if (!providerProject)
+                return null;
+            return {
+                id: dbProject.id,
+                name: providerProject.name,
+                deployable: providerProject.deployable,
+            };
+        })
+            .filter((update) => update !== null);
+        if (toUpdate.length > 0) {
+            await this.updateBatch(toUpdate);
+        }
+        return providerProjects.map((project) => ({
+            id: selectedMap.get(project.id)?.id ?? null,
+            external_id: project.id,
+            name: project.name,
+            deployable: project.deployable,
+            framework: project.framework,
+        }));
+    }
+    /**
+     * Validate that all projects to create are deployable.
+     */
+    async validateDeployable(provider, projectsToCreate) {
+        if (projectsToCreate.length === 0)
+            return;
+        const config = await this.readConfig(provider);
+        const driver = this.createDriver(config);
+        const providerProjects = await driver.listProjects();
+        const projectsMap = new Map(providerProjects.map((p) => [p.id, p]));
+        const nonDeployable = projectsToCreate.filter((p) => !projectsMap.get(p.external_id)?.deployable);
+        if (nonDeployable.length > 0) {
+            const names = nonDeployable.map((p) => projectsMap.get(p.external_id)?.name || p.external_id).join(', ');
+            throw new InvalidPayloadError({
+                reason: `Cannot add non-deployable projects: ${names}`,
+            });
+        }
+    }
     /**
      * Update project selection (create/delete)
      */
-    async updateSelection(deploymentId, create, deleteIds) {
+    async updateSelection(provider, create, deleteIds) {
+        const config = await this.readConfig(provider);
         const db = getDatabase();
+        const driver = this.createDriver(config);
+        // Fetch metadata for new projects
+        const enrichedCreate = await Promise.all(create.map(async (p) => {
+            const details = await driver.getProject(p.external_id);
+            return {
+                external_id: p.external_id,
+                name: p.name,
+                url: details.url ?? null,
+                framework: details.framework ?? null,
+                deployable: details.deployable,
+            };
+        }));
         return transaction(db, async (trx) => {
             const trxService = new DeploymentProjectsService({
                 accountability: this.accountability,
@@ -19,16 +96,43 @@ export class DeploymentProjectsService extends ItemsService {
             if (deleteIds.length > 0) {
                 await trxService.deleteMany(deleteIds);
             }
-            if (create.length > 0) {
-                await trxService.createMany(create.map((p) => ({
-                    deployment: deploymentId,
+            if (enrichedCreate.length > 0) {
+                await trxService.createMany(enrichedCreate.map((p) => ({
+                    deployment: config.id,
                     external_id: p.external_id,
                     name: p.name,
+                    url: p.url,
+                    framework: p.framework,
+                    deployable: p.deployable,
                 })));
             }
             return trxService.readByQuery({
-                filter: { deployment: { _eq: deploymentId } },
+                filter: { deployment: { _eq: config.id } },
+                limit: -1,
             });
         });
     }
+    /**
+     * Read deployment config by provider (null accountability for internal use).
+     */
+    async readConfig(provider) {
+        const internalService = new ItemsService('directus_deployments', {
+            knex: this.knex,
+            schema: this.schema,
+            accountability: null,
+        });
+        const results = await internalService.readByQuery({
+            filter: { provider: { _eq: provider } },
+            limit: 1,
+        });
+        if (!results || results.length === 0) {
+            throw new Error(`Deployment config for "${provider}" not found`);
+        }
+        return results[0];
+    }
+    createDriver(config) {
+        const credentials = parseValue(config.credentials, {});
+        const options = parseValue(config.options, {});
+        return getDeploymentDriver(config.provider, credentials, options);
+    }
 }

package/dist/services/deployment-runs.d.ts

@@ -1,13 +1,31 @@
-import type { AbstractServiceOptions } from '@directus/types';
+import type { AbstractServiceOptions, DeploymentWebhookEvent } from '@directus/types';
 import { ItemsService } from './items.js';
 export interface DeploymentRun {
     id: string;
     project: string;
     external_id: string;
     target: string;
+    status: string | null;
+    url: string | null;
+    started_at: string | null;
+    completed_at: string | null;
     date_created: string;
     user_created: string;
 }
 export declare class DeploymentRunsService extends ItemsService<DeploymentRun> {
     constructor(options: AbstractServiceOptions);
+    /**
+     * Process a webhook event: create or update a run based on the event data.
+     * Returns the run ID.
+     */
+    processWebhookEvent(projectId: string, event: DeploymentWebhookEvent): Promise<string>;
+    /**
+     * Get run stats for a project within a date range
+     */
+    getStats(projectId: string, sinceDate: string): Promise<{
+        total_deployments: number;
+        average_build_time: number | null;
+        failed_builds: number;
+        successful_builds: number;
+    }>;
 }

package/dist/services/deployment-runs.js

@@ -3,4 +3,90 @@ export class DeploymentRunsService extends ItemsService {
     constructor(options) {
         super('directus_deployment_runs', options);
     }
+    /**
+     * Process a webhook event: create or update a run based on the event data.
+     * Returns the run ID.
+     */
+    async processWebhookEvent(projectId, event) {
+        const existingRuns = await this.readByQuery({
+            filter: {
+                project: { _eq: projectId },
+                external_id: { _eq: event.deployment_external_id },
+            },
+            limit: 1,
+        });
+        const isTerminal = event.type === 'deployment.succeeded' ||
+            event.type === 'deployment.error' ||
+            event.type === 'deployment.canceled';
+        if (existingRuns && existingRuns.length > 0) {
+            const existingRun = existingRuns[0];
+            await this.updateOne(existingRun.id, {
+                status: event.status,
+                ...(event.url ? { url: event.url } : {}),
+                ...(event.type === 'deployment.created' && !existingRun.started_at
+                    ? { started_at: event.timestamp.toISOString() }
+                    : {}),
+                ...(isTerminal ? { completed_at: event.timestamp.toISOString() } : {}),
+            });
+            return existingRun.id;
+        }
+        return (await this.createOne({
+            project: projectId,
+            external_id: event.deployment_external_id,
+            target: event.target || 'production',
+            status: event.status,
+            ...(event.url ? { url: event.url } : {}),
+            started_at: event.type === 'deployment.created' ? event.timestamp.toISOString() : null,
+            ...(isTerminal ? { completed_at: event.timestamp.toISOString() } : {}),
+        }));
+    }
+    /**
+     * Get run stats for a project within a date range
+     */
+    async getStats(projectId, sinceDate) {
+        const dateFilter = {
+            _and: [{ project: { _eq: projectId } }, { date_created: { _gte: sinceDate } }],
+        };
+        const [countResult, completedRuns, statusCounts] = await Promise.all([
+            this.readByQuery({
+                filter: dateFilter,
+                aggregate: { count: ['*'] },
+            }),
+            this.readByQuery({
+                filter: {
+                    _and: [
+                        { project: { _eq: projectId } },
+                        { date_created: { _gte: sinceDate } },
+                        { started_at: { _nnull: true } },
+                        { completed_at: { _nnull: true } },
+                    ],
+                },
+                fields: ['started_at', 'completed_at'],
+                limit: -1,
+            }),
+            this.readByQuery({
+                filter: {
+                    _and: [
+                        { project: { _eq: projectId } },
+                        { date_created: { _gte: sinceDate } },
+                        { status: { _in: ['ready', 'error'] } },
+                    ],
+                },
+                aggregate: { count: ['*'] },
+                group: ['status'],
+            }),
+        ]);
+        let averageBuildTime = null;
+        if (completedRuns.length > 0) {
+            const durations = completedRuns.map((r) => new Date(r.completed_at).getTime() - new Date(r.started_at).getTime());
+            averageBuildTime = Math.round(durations.reduce((a, b) => a + b, 0) / durations.length);
+        }
+        const statusMap = new Map(statusCounts.map((r) => [r.status, Number(r.count)]));
+        return {
+            total_deployments: Number(countResult[0]?.['count'] ?? 0),
+            average_build_time: averageBuildTime,
+            failed_builds: statusMap.get('error') ?? 0,
+            successful_builds: statusMap.get('ready') ?? 0,
+        };
+    }
 }

package/dist/services/deployment.d.ts

@@ -1,5 +1,6 @@
-import type { AbstractServiceOptions, CachedResult, DeploymentConfig, PrimaryKey, Project, ProviderType, Query } from '@directus/types';
+import type { AbstractServiceOptions, CachedResult, Credentials, DeploymentConfig, Options, PrimaryKey, Project, ProviderType, Query } from '@directus/types';
 import type { DeploymentDriver } from '../deployment/deployment.js';
+import type { DeploymentRun } from './deployment-runs.js';
 import { ItemsService } from './items.js';
 export declare class DeploymentService extends ItemsService<DeploymentConfig> {
     constructor(options: AbstractServiceOptions);
@@ -22,13 +23,21 @@ export declare class DeploymentService extends ItemsService<DeploymentConfig> {
      */
     private readConfig;
     /**
-     * Parse JSON string or return value as-is
+     * Get webhook config for a provider
      */
-    private parseValue;
+    getWebhookConfig(provider: ProviderType): Promise<{
+        webhook_secret: string | null;
+        credentials: Credentials;
+        options: Options;
+    }>;
     /**
      * Get a deployment driver instance with decrypted credentials
      */
     getDriver(provider: ProviderType): Promise<DeploymentDriver>;
+    /**
+     * Sync webhook registration with current tracked projects.
+     */
+    syncWebhook(provider: ProviderType): Promise<void>;
     /**
      * List projects from provider with caching
      */
@@ -37,4 +46,36 @@ export declare class DeploymentService extends ItemsService<DeploymentConfig> {
      * Get project details from provider with caching
      */
     getProviderProject(provider: ProviderType, projectId: string): Promise<CachedResult<Project>>;
+    /**
+     * Dashboard: projects + latest run status + stats
+     */
+    getDashboard(provider: ProviderType, sinceDate: Date): Promise<{
+        projects: any[];
+        stats: {
+            active_deployments: number;
+            successful_builds: number;
+            failed_builds: number;
+        };
+    }>;
+    /**
+     * Refresh project metadata (name, url, framework, deployable) if stale.
+     */
+    private syncProjectMetadataIfStale;
+    /**
+     * Trigger a deployment for a project
+     */
+    triggerDeployment(provider: ProviderType, projectId: string, options: {
+        preview: boolean;
+        clearCache: boolean;
+    }): Promise<DeploymentRun>;
+    /**
+     * Cancel a deployment run
+     */
+    cancelDeployment(provider: ProviderType, runId: string): Promise<DeploymentRun>;
+    /**
+     * Get a run with its logs from the provider
+     */
+    getRunWithLogs(provider: ProviderType, runId: string, since?: Date): Promise<DeploymentRun & {
+        logs: any;
+    }>;
 }