@directus/api 33.0.0 → 33.1.1

package/dist/deployment/deployment.d.ts

@@ -0,0 +1,94 @@
+import type { Credentials, Deployment, Details, Log, Options, Project, TriggerResult } from '@directus/types';
+import type { AxiosRequestConfig, AxiosResponse } from 'axios';
+export type DeploymentRequestOptions = Pick<AxiosRequestConfig<string>, 'method' | 'headers'> & {
+    body?: string | null;
+    params?: Record<string, string>;
+};
+export declare abstract class DeploymentDriver<TCredentials extends Credentials = Credentials, TOptions extends Options = Options> {
+    credentials: TCredentials;
+    options: TOptions;
+    constructor(credentials: TCredentials, options?: TOptions);
+    protected axiosRequest<T>(apiUrl: string, endpoint: string, options?: DeploymentRequestOptions): Promise<AxiosResponse<T>>;
+    /**
+     * Test connection with provider using credentials
+     *
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     */
+    abstract testConnection(): Promise<void>;
+    /**
+     * List all available projects from provider
+     *
+     * @returns Array of external projects
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract listProjects(): Promise<Project[]>;
+    /**
+     * Get project details by ID
+     *
+     * @param projectId External project ID
+     * @returns Project details
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract getProject(projectId: string): Promise<Project>;
+    /**
+     * List deployments for a project
+     *
+     * @param projectId External project ID
+     * @param limit Number of deployments to return
+     * @returns Array of deployments
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract listDeployments(projectId: string, limit?: number): Promise<Deployment[]>;
+    /**
+     * Get deployment details including logs
+     *
+     * @param deploymentId External deployment ID
+     * @returns Deployment details with logs
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract getDeployment(deploymentId: string): Promise<Details>;
+    /**
+     * Trigger a new deployment
+     *
+     * @param projectId External project ID
+     * @param options Deployment options
+     * @returns Deployment result
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract triggerDeployment(projectId: string, options?: {
+        preview?: boolean;
+        clearCache?: boolean;
+    }): Promise<TriggerResult>;
+    /**
+     * Cancel a running deployment
+     *
+     * @param deploymentId External deployment ID
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract cancelDeployment(deploymentId: string): Promise<void>;
+    /**
+     * Get deployment build logs
+     *
+     * @param deploymentId External deployment ID
+     * @param options.since Only return logs after this timestamp
+     * @returns Array of log entries
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract getDeploymentLogs(deploymentId: string, options?: {
+        since?: Date;
+    }): Promise<Log[]>;
+}

package/dist/deployment/deployment.js

@@ -0,0 +1,29 @@
+import { getAxios } from '../request/index.js';
+export class DeploymentDriver {
+    credentials;
+    options;
+    constructor(credentials, options = {}) {
+        this.credentials = credentials;
+        this.options = options;
+    }
+    async axiosRequest(apiUrl, endpoint, options = {}) {
+        const { params, ...requestOptions } = options;
+        const url = new URL(endpoint, apiUrl);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                url.searchParams.set(key, value);
+            }
+        }
+        const axios = await getAxios();
+        const requestConfig = {
+            url: url.toString(),
+            method: requestOptions.method ?? 'GET',
+            validateStatus: () => true,
+            headers: requestOptions.headers ?? {},
+        };
+        if (requestOptions.body) {
+            requestConfig.data = requestOptions.body;
+        }
+        return await axios.request(requestConfig);
+    }
+}

package/dist/deployment/drivers/index.d.ts

@@ -0,0 +1 @@
+export * from './vercel.js';

package/dist/deployment/drivers/index.js

@@ -0,0 +1 @@
+export * from './vercel.js';

package/dist/deployment/drivers/vercel.d.ts

@@ -0,0 +1,32 @@
+import type { Credentials, Deployment, Details, Log, Options, Project, TriggerResult } from '@directus/types';
+import { DeploymentDriver } from '../deployment.js';
+export interface VercelCredentials extends Credentials {
+    access_token: string;
+}
+export interface VercelOptions extends Options {
+    team_id?: string;
+}
+export declare class VercelDriver extends DeploymentDriver<VercelCredentials, VercelOptions> {
+    private static readonly API_URL;
+    private requestLimit;
+    constructor(credentials: VercelCredentials, options?: VercelOptions);
+    /**
+     * Make authenticated request with retry on rate limit and concurrency control
+     */
+    private request;
+    private mapStatus;
+    testConnection(): Promise<void>;
+    private mapProjectBase;
+    listProjects(): Promise<Project[]>;
+    getProject(projectId: string): Promise<Project>;
+    listDeployments(projectId: string, limit?: number): Promise<Deployment[]>;
+    getDeployment(deploymentId: string): Promise<Details>;
+    triggerDeployment(projectId: string, options?: {
+        preview?: boolean;
+        clearCache?: boolean;
+    }): Promise<TriggerResult>;
+    cancelDeployment(deploymentId: string): Promise<void>;
+    getDeploymentLogs(deploymentId: string, options?: {
+        since?: Date;
+    }): Promise<Log[]>;
+}

package/dist/deployment/drivers/vercel.js

@@ -0,0 +1,208 @@
+import { HitRateLimitError, InvalidCredentialsError, ServiceUnavailableError } from '@directus/errors';
+import pLimit from 'p-limit';
+import { DeploymentDriver } from '../deployment.js';
+export class VercelDriver extends DeploymentDriver {
+    static API_URL = 'https://api.vercel.com';
+    requestLimit = pLimit(5);
+    constructor(credentials, options = {}) {
+        super(credentials, options);
+    }
+    /**
+     * Make authenticated request with retry on rate limit and concurrency control
+     */
+    async request(endpoint, options = {}, retryCount = 0) {
+        return this.requestLimit(async () => {
+            const response = await this.axiosRequest(VercelDriver.API_URL, endpoint, {
+                ...options,
+                headers: {
+                    Authorization: `Bearer ${this.credentials.access_token}`,
+                    'Content-Type': 'application/json',
+                    ...(options.headers ?? {}),
+                },
+                params: {
+                    ...(this.options.team_id ? { teamId: this.options.team_id } : {}),
+                    ...(options.params ?? {}),
+                },
+            });
+            // Handle rate limiting with retry (max 3 retries)
+            if (response.status === 429) {
+                const resetAt = parseInt(response.headers['x-ratelimit-reset'] || '0');
+                const limit = parseInt(response.headers['x-ratelimit-limit'] || '0');
+                if (retryCount < 3) {
+                    const waitTime = resetAt > 0 ? Math.max(resetAt * 1000 - Date.now(), 1000) : 1000 * (retryCount + 1);
+                    await new Promise((resolve) => setTimeout(resolve, waitTime));
+                    return this.request(endpoint, options, retryCount + 1);
+                }
+                // Max retries exceeded
+                throw new HitRateLimitError({
+                    limit,
+                    reset: new Date(resetAt > 0 ? resetAt * 1000 : Date.now()),
+                });
+            }
+            const body = response.data;
+            if (response.status >= 400) {
+                const message = typeof body === 'object' && body !== null && 'error' in body
+                    ? body.error?.message || `Vercel API error: ${response.status}`
+                    : `Vercel API error: ${response.status}`;
+                if (response.status === 401 || response.status === 403) {
+                    throw new InvalidCredentialsError();
+                }
+                throw new ServiceUnavailableError({ service: 'vercel', reason: message });
+            }
+            return body;
+        });
+    }
+    mapStatus(vercelStatus) {
+        const normalized = vercelStatus?.toLowerCase();
+        switch (normalized) {
+            case 'building':
+            case 'error':
+            case 'canceled':
+            case 'ready':
+                return normalized;
+            case 'queued':
+            case 'initializing':
+            case 'analyzing':
+            case 'deploying':
+            default:
+                return 'building';
+        }
+    }
+    async testConnection() {
+        return await this.request('/v9/projects', { params: { limit: '1' } });
+    }
+    mapProjectBase(project) {
+        const result = {
+            id: project.id,
+            name: project.name,
+            deployable: Boolean(project.link?.type),
+        };
+        if (project.framework) {
+            result.framework = project.framework;
+        }
+        return result;
+    }
+    async listProjects() {
+        const response = await this.request('/v9/projects');
+        return response.projects.map((project) => this.mapProjectBase(project));
+    }
+    async getProject(projectId) {
+        const project = await this.request(`/v9/projects/${projectId}`);
+        const result = this.mapProjectBase(project);
+        const production = project.targets?.production;
+        if (production?.alias?.[0]) {
+            result.url = `https://${production.alias[0]}`;
+        }
+        // Latest deployment info from detail endpoint
+        if (production?.readyState && production.createdAt) {
+            result.latest_deployment = {
+                status: this.mapStatus(production.readyState),
+                created_at: new Date(production.createdAt),
+                ...(production.readyAt && { finished_at: new Date(production.readyAt) }),
+            };
+        }
+        if (project.createdAt) {
+            result.created_at = new Date(project.createdAt);
+        }
+        if (project.updatedAt) {
+            result.updated_at = new Date(project.updatedAt);
+        }
+        return result;
+    }
+    async listDeployments(projectId, limit = 20) {
+        const url = `/v6/deployments?projectId=${encodeURIComponent(projectId)}&limit=${limit}`;
+        const response = await this.request(url);
+        return response.deployments.map((deployment) => {
+            const result = {
+                id: deployment.uid,
+                project_id: deployment.projectId ?? projectId,
+                status: this.mapStatus(deployment.state),
+                created_at: new Date(deployment.createdAt),
+            };
+            if (deployment.url) {
+                result.url = `https://${deployment.url}`;
+            }
+            if (deployment.ready) {
+                result.finished_at = new Date(deployment.ready);
+            }
+            return result;
+        });
+    }
+    async getDeployment(deploymentId) {
+        const deployment = await this.request(`/v13/deployments/${encodeURIComponent(deploymentId)}`);
+        const result = {
+            id: deployment.id,
+            project_id: deployment.projectId ?? '',
+            status: this.mapStatus(deployment.status || deployment.state),
+            created_at: new Date(deployment.createdAt),
+        };
+        if (deployment.url) {
+            result.url = `https://${deployment.url}`;
+        }
+        if (deployment.ready) {
+            result.finished_at = new Date(deployment.ready);
+        }
+        return result;
+    }
+    async triggerDeployment(projectId, options) {
+        // Fetch project to get realtime required name needed for the vercel request
+        const project = await this.request(`/v9/projects/${projectId}`);
+        const body = {
+            name: project.name,
+            project: projectId,
+        };
+        if (!options?.preview) {
+            body['target'] = 'production';
+        }
+        // Add required gitSource
+        if (project.link?.type) {
+            body['gitSource'] = {
+                type: project.link.type,
+                ref: project.link.productionBranch,
+                repoId: project.link.repoId,
+            };
+        }
+        // forceNew=1 skips build cache when clearCache is true
+        const response = await this.request('/v13/deployments', {
+            method: 'POST',
+            body: JSON.stringify(body),
+            ...(options?.clearCache && { params: { forceNew: '1' } }),
+        });
+        const triggerResult = {
+            deployment_id: response.id,
+            status: this.mapStatus(response.status),
+        };
+        if (response.url) {
+            triggerResult.url = `https://${response.url}`;
+        }
+        return triggerResult;
+    }
+    async cancelDeployment(deploymentId) {
+        await this.request(`/v12/deployments/${encodeURIComponent(deploymentId)}/cancel`, {
+            method: 'PATCH',
+        });
+    }
+    async getDeploymentLogs(deploymentId, options) {
+        let url = `/v3/deployments/${encodeURIComponent(deploymentId)}/events`;
+        // Vercel's since parameter uses milliseconds timestamp
+        if (options?.since) {
+            const sinceMs = options.since.getTime();
+            url += `?since=${sinceMs}`;
+        }
+        const response = await this.request(url);
+        const mapEventType = (type) => {
+            if (type === 'stderr')
+                return 'stderr';
+            if (type === 'command')
+                return 'info';
+            return 'stdout';
+        };
+        return response
+            .filter((event) => event.type === 'stdout' || event.type === 'stderr' || event.type === 'command')
+            .map((event) => ({
+            timestamp: new Date(event.created),
+            type: mapEventType(event.type),
+            message: event.text || event.payload?.text || '',
+        }));
+    }
+}

package/dist/deployment/index.d.ts

@@ -0,0 +1,2 @@
+export * from './deployment.js';
+export * from './drivers/index.js';

package/dist/deployment/index.js

@@ -0,0 +1,2 @@
+export * from './deployment.js';
+export * from './drivers/index.js';

package/dist/deployment.d.ts

@@ -0,0 +1,24 @@
+import type { Credentials, Options, ProviderType } from '@directus/types';
+import type { DeploymentDriver } from './deployment/deployment.js';
+/**
+ * Register all deployment drivers
+ */
+export declare function registerDeploymentDrivers(): void;
+/**
+ * Get a deployment driver instance
+ *
+ * @param provider Provider name (vercel, netlify, aws, etc.)
+ * @param credentials Provider credentials (decrypted from DB)
+ * @param options Additional provider options
+ * @returns Deployment driver instance
+ * @throws Error if provider is not supported
+ */
+export declare function getDeploymentDriver(provider: ProviderType, credentials: Credentials, options?: Options): DeploymentDriver;
+/**
+ * Check if a provider is supported
+ */
+export declare function isValidProviderType(provider: string): provider is ProviderType;
+/**
+ * Get list of supported provider types
+ */
+export declare function getSupportedProviderTypes(): ProviderType[];

package/dist/deployment.js

@@ -0,0 +1,39 @@
+import { VercelDriver } from './deployment/drivers/index.js';
+/**
+ * Registry of deployment driver constructors
+ */
+const drivers = new Map();
+/**
+ * Register all deployment drivers
+ */
+export function registerDeploymentDrivers() {
+    drivers.set('vercel', VercelDriver);
+}
+/**
+ * Get a deployment driver instance
+ *
+ * @param provider Provider name (vercel, netlify, aws, etc.)
+ * @param credentials Provider credentials (decrypted from DB)
+ * @param options Additional provider options
+ * @returns Deployment driver instance
+ * @throws Error if provider is not supported
+ */
+export function getDeploymentDriver(provider, credentials, options) {
+    const Driver = drivers.get(provider);
+    if (!Driver) {
+        throw new Error(`Deployment driver "${provider}" is not supported`);
+    }
+    return new Driver(credentials, options);
+}
+/**
+ * Check if a provider is supported
+ */
+export function isValidProviderType(provider) {
+    return drivers.has(provider);
+}
+/**
+ * Get list of supported provider types
+ */
+export function getSupportedProviderTypes() {
+    return Array.from(drivers.keys());
+}

package/dist/middleware/respond.js

@@ -15,6 +15,10 @@ export const respond = asyncHandler(async (req, res) => {
     const env = useEnv();
     const logger = useLogger();
     const { cache } = getCache();
+    // Support custom cache instance and TTL via res.locals
+    const cacheInstance = res.locals['cacheInstance'] || cache;
+    const cacheTTL = res.locals['cacheTTL'] ?? getMilliseconds(env['CACHE_TTL']);
+    const hasCustomCache = !!res.locals['cacheInstance'];
     let exceedsMaxSize = false;
     if (env['CACHE_VALUE_MAX_SIZE'] !== false) {
         const valueSize = res.locals['payload'] ? stringByteSize(JSON.stringify(res.locals['payload'])) : 0;
@@ -22,26 +26,35 @@ export const respond = asyncHandler(async (req, res) => {
         if (maxSize !== null)
             exceedsMaxSize = valueSize > maxSize;
     }
-    if ((req.method.toLowerCase() === 'get' || req.originalUrl?.startsWith('/graphql')) &&
-        req.originalUrl?.startsWith('/auth') === false &&
-        env['CACHE_ENABLED'] === true &&
-        cache &&
-        !req.sanitizedQuery.export &&
-        res.locals['cache'] !== false &&
-        exceedsMaxSize === false &&
-        (await permissionsCacheable(req.collection, {
-            knex: getDatabase(),
-            schema: req.schema,
-        }, req.accountability))) {
+    // Custom cache bypasses global cache settings (CACHE_ENABLED, permissionsCacheable)
+    const shouldCache = hasCustomCache
+        ? res.locals['cache'] !== false && cacheInstance && !req.sanitizedQuery.export && exceedsMaxSize === false
+        : (req.method.toLowerCase() === 'get' || req.originalUrl?.startsWith('/graphql')) &&
+            req.originalUrl?.startsWith('/auth') === false &&
+            env['CACHE_ENABLED'] === true &&
+            cache &&
+            !req.sanitizedQuery.export &&
+            res.locals['cache'] !== false &&
+            exceedsMaxSize === false &&
+            (await permissionsCacheable(req.collection, {
+                knex: getDatabase(),
+                schema: req.schema,
+            }, req.accountability));
+    if (shouldCache) {
         const key = await getCacheKey(req);
         try {
-            await setCacheValue(cache, key, res.locals['payload'], getMilliseconds(env['CACHE_TTL']));
-            await setCacheValue(cache, `${key}__expires_at`, { exp: Date.now() + getMilliseconds(env['CACHE_TTL'], 0) });
+            await setCacheValue(cacheInstance, key, res.locals['payload'], cacheTTL);
+            await setCacheValue(cacheInstance, `${key}__expires_at`, { exp: Date.now() + cacheTTL });
         }
         catch (err) {
             logger.warn(err, `[cache] Couldn't set key ${key}. ${err}`);
         }
-        res.setHeader('Cache-Control', getCacheControlHeader(req, getMilliseconds(env['CACHE_TTL']), true, true));
+        res.setHeader('Cache-Control', getCacheControlHeader(req, cacheTTL, !hasCustomCache, true));
+        res.setHeader('Vary', 'Origin, Cache-Control');
+    }
+    else if (res.locals['cacheTTL'] !== undefined) {
+        // Custom TTL for headers only (no storage) - useful when caching is handled elsewhere
+        res.setHeader('Cache-Control', getCacheControlHeader(req, cacheTTL, false, true));
         res.setHeader('Vary', 'Origin, Cache-Control');
     }
     else {

package/dist/permissions/modules/process-ast/utils/find-related-collection.js

@@ -1,4 +1,4 @@
-import { getRelationInfo } from '../../../../utils/get-relation-info.js';
+import { getRelationInfo } from '@directus/utils';
 export function findRelatedCollection(collection, field, schema) {
     const { relation } = getRelationInfo(schema.relations, collection, field);
     if (!relation)

package/dist/permissions/modules/validate-access/lib/validate-item-access.d.ts

@@ -4,7 +4,7 @@ export interface ValidateItemAccessOptions {
     accountability: Accountability;
     action: PermissionsAction;
     collection: string;
-    primaryKeys: PrimaryKey[];
+    primaryKeys?: PrimaryKey[];
     fields?: string[];
     returnAllowedRootFields?: boolean;
 }

package/dist/permissions/modules/validate-access/lib/validate-item-access.js

@@ -6,16 +6,23 @@ import { fetchAllowedFields } from '../../fetch-allowed-fields/fetch-allowed-fie
 import { injectCases } from '../../process-ast/lib/inject-cases.js';
 import { processAst } from '../../process-ast/process-ast.js';
 export async function validateItemAccess(options, context) {
-    const primaryKeyField = context.schema.collections[options.collection]?.primary;
+    const collectionInfo = context.schema.collections[options.collection];
+    const primaryKeyField = collectionInfo?.primary;
     if (!primaryKeyField) {
         throw new Error(`Cannot find primary key for collection "${options.collection}"`);
     }
+    const isSingleton = collectionInfo?.singleton === true;
+    const hasPrimaryKeys = options.primaryKeys && options.primaryKeys.length > 0;
+    // For non-singletons, we must have PKs to validate against
+    if (!isSingleton && !hasPrimaryKeys) {
+        throw new Error(`Primary keys are required for non-singleton collection "${options.collection}"`);
+    }
     // When we're looking up access to specific items, we have to read them from the database to
     // make sure you are allowed to access them.
     const ast = {
         type: 'root',
         name: options.collection,
-        query: { limit: options.primaryKeys.length },
+        query: { limit: isSingleton && !hasPrimaryKeys ? 1 : options.primaryKeys.length },
         // Act as if every field was a "normal" field
         children: options.fields?.map((field) => ({ type: 'field', name: field, fieldKey: field, whenCase: [], alias: false })) ??
             [],
@@ -23,11 +30,14 @@ export async function validateItemAccess(options, context) {
     };
     await processAst({ ast, ...options }, context);
     // Inject the filter after the permissions have been processed, as to not require access to the primary key
-    ast.query.filter = {
-        [primaryKeyField]: {
-            _in: options.primaryKeys,
-        },
-    };
+    // Skip adding filter for singletons without explicit PKs
+    if (hasPrimaryKeys) {
+        ast.query.filter = {
+            [primaryKeyField]: {
+                _in: options.primaryKeys,
+            },
+        };
+    }
     let hasItemRules;
     let permissionedFields;
     // Inject the root fields after the permissions have been processed, as to not require access to all collection fields
@@ -58,7 +68,8 @@ export async function validateItemAccess(options, context) {
         knex: context.knex,
         action: options.action,
     });
-    const hasAccess = items && items.length === options.primaryKeys.length;
+    const expectedCount = isSingleton && !hasPrimaryKeys ? 1 : options.primaryKeys.length;
+    const hasAccess = items && items.length === expectedCount;
     if (!hasAccess) {
         if (options.returnAllowedRootFields) {
             return { accessAllowed: false, allowedRootFields: [] };

package/dist/server.js

@@ -15,7 +15,7 @@ import { getAddress } from './utils/get-address.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getIPFromReq } from './utils/get-ip-from-req.js';
 import { createLogsController, createSubscriptionController, createWebSocketController, getLogsController, getSubscriptionController, getWebSocketController, } from './websocket/controllers/index.js';
-import { startWebSocketHandlers } from './websocket/handlers/index.js';
+import { getCollabHandler, startWebSocketHandlers } from './websocket/handlers/index.js';
 export let SERVER_ONLINE = true;
 const env = useEnv();
 const logger = useLogger();
@@ -101,6 +101,7 @@ export async function createServer() {
         getSubscriptionController()?.terminate();
         getWebSocketController()?.terminate();
         getLogsController()?.terminate();
+        await getCollabHandler()?.terminate();
         const database = getDatabase();
         await database.destroy();
         logger.info('Database connections destroyed');

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

@@ -0,0 +1,20 @@
+import type { AbstractServiceOptions, PrimaryKey } from '@directus/types';
+import { ItemsService } from './items.js';
+export interface DeploymentProject {
+    id: string;
+    deployment: string;
+    external_id: string;
+    name: string;
+    date_created: string;
+    user_created: string;
+}
+export declare class DeploymentProjectsService extends ItemsService<DeploymentProject> {
+    constructor(options: AbstractServiceOptions);
+    /**
+     * Update project selection (create/delete)
+     */
+    updateSelection(deploymentId: string, create: {
+        external_id: string;
+        name: string;
+    }[], deleteIds: PrimaryKey[]): Promise<DeploymentProject[]>;
+}

package/dist/services/deployment-projects.js

@@ -0,0 +1,34 @@
+import getDatabase from '../database/index.js';
+import { transaction } from '../utils/transaction.js';
+import { ItemsService } from './items.js';
+export class DeploymentProjectsService extends ItemsService {
+    constructor(options) {
+        super('directus_deployment_projects', options);
+    }
+    /**
+     * Update project selection (create/delete)
+     */
+    async updateSelection(deploymentId, create, deleteIds) {
+        const db = getDatabase();
+        return transaction(db, async (trx) => {
+            const trxService = new DeploymentProjectsService({
+                accountability: this.accountability,
+                schema: this.schema,
+                knex: trx,
+            });
+            if (deleteIds.length > 0) {
+                await trxService.deleteMany(deleteIds);
+            }
+            if (create.length > 0) {
+                await trxService.createMany(create.map((p) => ({
+                    deployment: deploymentId,
+                    external_id: p.external_id,
+                    name: p.name,
+                })));
+            }
+            return trxService.readByQuery({
+                filter: { deployment: { _eq: deploymentId } },
+            });
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { AbstractServiceOptions } from '@directus/types';
+import { ItemsService } from './items.js';
+export interface DeploymentRun {
+    id: string;
+    project: string;
+    external_id: string;
+    target: string;
+    date_created: string;
+    user_created: string;
+}
+export declare class DeploymentRunsService extends ItemsService<DeploymentRun> {
+    constructor(options: AbstractServiceOptions);
+}