@directus/api 31.0.0 → 32.0.0

package/dist/services/meta.js

@@ -1,8 +1,10 @@
 import { isArray } from 'lodash-es';
-import { getAstFromQuery } from '../database/get-ast-from-query/get-ast-from-query.js';
 import getDatabase from '../database/index.js';
-import { runAst } from '../database/run-ast/run-ast.js';
-import { processAst } from '../permissions/modules/process-ast/process-ast.js';
+import applyQuery from '../database/run-ast/lib/apply-query/index.js';
+import { fetchPermissions } from '../permissions/lib/fetch-permissions.js';
+import { fetchPolicies } from '../permissions/lib/fetch-policies.js';
+import { getCases } from '../permissions/modules/process-ast/lib/get-cases.js';
+import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 export class MetaService {
     knex;
     accountability;
@@ -33,27 +35,29 @@ export class MetaService {
         return this.filterCount(collection, {});
     }
     async filterCount(collection, query) {
-        const primaryKeyName = this.schema.collections[collection].primary;
-        const aggregateQuery = {
-            aggregate: {
-                countDistinct: [primaryKeyName],
-            },
-            search: query.search ?? null,
+        let permissions = [];
+        if (this.accountability && this.accountability.admin !== true) {
+            const context = { knex: this.knex, schema: this.schema };
+            await validateAccess({
+                accountability: this.accountability,
+                action: 'read',
+                collection,
+            }, context);
+            const policies = await fetchPolicies(this.accountability, context);
+            permissions = await fetchPermissions({ action: 'read', accountability: this.accountability, policies }, context);
+        }
+        const { cases } = getCases(collection, permissions, []);
+        const { query: dbQuery, hasJoins } = applyQuery(this.knex, collection, this.knex(collection), {
             filter: query.filter ?? null,
-        };
-        let ast = await getAstFromQuery({
-            collection,
-            query: aggregateQuery,
-            accountability: this.accountability,
-        }, {
-            schema: this.schema,
-            knex: this.knex,
-        });
-        ast = await processAst({ ast, action: 'read', accountability: this.accountability }, { knex: this.knex, schema: this.schema });
-        const records = await runAst(ast, this.schema, this.accountability, {
-            knex: this.knex,
-        });
-        return Number((isArray(records) ? records[0]?.['countDistinct'][primaryKeyName] : records?.['countDistinct'][primaryKeyName]) ??
-            0);
+            search: query.search ?? null,
+        }, this.schema, cases, permissions);
+        if (hasJoins) {
+            dbQuery.countDistinct({ count: [`${collection}.${this.schema.collections[collection].primary}`] });
+        }
+        else {
+            dbQuery.count('*', { as: 'count' });
+        }
+        const records = await dbQuery;
+        return Number((isArray(records) ? records[0]?.['count'] : records?.['count']) ?? 0);
     }
 }

package/dist/services/schema.js

@@ -34,7 +34,10 @@ export class SchemaService {
         validateSnapshot(snapshot, options?.force);
         const currentSnapshot = options?.currentSnapshot ?? (await getSnapshot({ database: this.knex }));
         const diff = getSnapshotDiff(currentSnapshot, snapshot);
-        if (diff.collections.length === 0 && diff.fields.length === 0 && diff.relations.length === 0) {
+        if (diff.collections.length === 0 &&
+            diff.fields.length === 0 &&
+            diff.relations.length === 0 &&
+            (!diff.systemFields || diff.systemFields.length === 0)) {
             return null;
         }
         return diff;

package/dist/services/server.d.ts

@@ -7,6 +7,7 @@ export declare class ServerService {
     settingsService: SettingsService;
     schema: SchemaOverview;
     constructor(options: AbstractServiceOptions);
+    isSetupCompleted(): Promise<boolean>;
     serverInfo(): Promise<Record<string, any>>;
     health(): Promise<Record<string, any>>;
 }

package/dist/services/server.js

@@ -28,8 +28,12 @@ export class ServerService {
         this.schema = options.schema;
         this.settingsService = new SettingsService({ knex: this.knex, schema: this.schema });
     }
+    async isSetupCompleted() {
+        return Boolean(await this.knex('directus_users').first());
+    }
     async serverInfo() {
         const info = {};
+        const setupComplete = await this.isSetupCompleted();
         const projectInfo = await this.settingsService.readSingleton({
             fields: [
                 'project_name',
@@ -54,6 +58,7 @@ export class ServerService {
         });
         info['project'] = projectInfo;
         info['mcp_enabled'] = toBoolean(env['MCP_ENABLED'] ?? true);
+        info['setupCompleted'] = setupComplete;
         if (this.accountability?.user) {
             if (env['RATE_LIMITER_ENABLED']) {
                 info['rateLimit'] = {
@@ -112,8 +117,9 @@ export class ServerService {
                     chunkSize: RESUMABLE_UPLOADS.CHUNK_SIZE,
                 };
             }
-            info['version'] = version;
         }
+        if (this.accountability?.user || !setupComplete)
+            info['version'] = version;
         return info;
     }
     async health() {
@@ -222,8 +228,8 @@ export class ServerService {
             };
             const startTime = performance.now();
             try {
-                await cache.set(`health-${checkID}`, true, 5);
-                await cache.delete(`health-${checkID}`);
+                await cache.set(`directus-health-${checkID}`, true, 5);
+                await cache.delete(`directus-health-${checkID}`);
             }
             catch (err) {
                 checks['cache:responseTime'][0].status = 'error';
@@ -256,8 +262,8 @@ export class ServerService {
             };
             const startTime = performance.now();
             try {
-                await rateLimiter.consume(`health-${checkID}`, 1);
-                await rateLimiter.delete(`health-${checkID}`);
+                await rateLimiter.consume(`directus-health-${checkID}`, 1);
+                await rateLimiter.delete(`directus-health-${checkID}`);
             }
             catch (err) {
                 checks['rateLimiter:responseTime'][0].status = 'error';
@@ -292,8 +298,8 @@ export class ServerService {
             };
             const startTime = performance.now();
             try {
-                await rateLimiterGlobal.consume(`health-${checkID}`, 1);
-                await rateLimiterGlobal.delete(`health-${checkID}`);
+                await rateLimiterGlobal.consume(`directus-health-${checkID}`, 1);
+                await rateLimiterGlobal.delete(`directus-health-${checkID}`);
             }
             catch (err) {
                 checks['rateLimiterGlobal:responseTime'][0].status = 'error';
@@ -327,17 +333,7 @@ export class ServerService {
                 ];
                 const startTime = performance.now();
                 try {
-                    await disk.write(`health-${checkID}`, Readable.from(['check']));
-                    const fileStream = await disk.read(`health-${checkID}`);
-                    fileStream.on('data', async () => {
-                        try {
-                            fileStream.destroy();
-                            await disk.delete(`health-${checkID}`);
-                        }
-                        catch (error) {
-                            logger.error(error);
-                        }
-                    });
+                    await disk.write('directus-health-file', Readable.from([checkID]));
                 }
                 catch (err) {
                     checks[`storage:${location}:responseTime`][0].status = 'error';

package/dist/services/settings.d.ts

@@ -1,5 +1,6 @@
-import type { AbstractServiceOptions } from '@directus/types';
+import type { AbstractServiceOptions, OwnerInformation } from '@directus/types';
 import { ItemsService } from './items.js';
 export declare class SettingsService extends ItemsService {
     constructor(options: AbstractServiceOptions);
+    setOwner(data: OwnerInformation): Promise<import("@directus/types").PrimaryKey>;
 }

package/dist/services/settings.js

@@ -1,6 +1,21 @@
 import { ItemsService } from './items.js';
+import { sendReport } from '../telemetry/index.js';
+import { version } from 'directus/version';
 export class SettingsService extends ItemsService {
     constructor(options) {
         super('directus_settings', options);
     }
+    async setOwner(data) {
+        const { project_id } = await this.knex.select('project_id').from('directus_settings').first();
+        sendReport({ ...data, project_id, version }).catch(async () => {
+            await this.knex.update('project_status', 'pending').from('directus_settings');
+        });
+        return await this.upsertSingleton({
+            project_owner: data.project_owner,
+            project_usage: data.project_usage,
+            org_name: data.org_name,
+            product_updates: data.product_updates,
+            project_status: null,
+        });
+    }
 }

package/dist/services/tus/server.js

@@ -6,7 +6,7 @@
 import { useEnv } from '@directus/env';
 import { supportsTus } from '@directus/storage';
 import { toArray } from '@directus/utils';
-import { Server, EVENTS } from '@tus/server';
+import { Server } from '@tus/server';
 import { RESUMABLE_UPLOADS } from '../../constants.js';
 import { getStorage } from '../../storage/index.js';
 import { extractMetadata } from '../files/lib/extract-metadata.js';
@@ -16,6 +16,7 @@ import { getTusLocker } from './lockers.js';
 import { pick } from 'lodash-es';
 import emitter from '../../emitter.js';
 import getDatabase from '../../database/index.js';
+import { getSchema } from '../../utils/get-schema.js';
 async function createTusStore(context) {
     const env = useEnv();
     const storage = await getStorage();
@@ -40,16 +41,17 @@ export async function createTusServer(context) {
         datastore: store,
         locker: getTusLocker(),
         ...(RESUMABLE_UPLOADS.MAX_SIZE !== null && { maxSize: RESUMABLE_UPLOADS.MAX_SIZE }),
-        async onUploadFinish(req, res, upload) {
+        async onUploadFinish(req, upload) {
+            const schema = await getSchema();
             const service = new ItemsService('directus_files', {
-                schema: req.schema,
+                schema,
             });
             const file = (await service.readByQuery({
                 filter: { tus_id: { _eq: upload.id } },
                 limit: 1,
             }))[0];
             if (!file)
-                return res;
+                return {};
             let fileData;
             // update metadata when file is replaced
             if (file.tus_data?.['metadata']?.['replace_id']) {
@@ -91,19 +93,22 @@ export async function createTusServer(context) {
                 collection: 'directus_files',
             }, {
                 database: getDatabase(),
-                schema: req.schema,
+                schema,
                 accountability: req.accountability,
             });
-            return res;
+            return {
+                headers: {
+                    'Directus-File-Id': upload.metadata['id'],
+                },
+            };
         },
         generateUrl(_req, opts) {
             return env['PUBLIC_URL'] + '/files/tus/' + opts.id;
         },
+        allowedHeaders: env['CORS_ALLOWED_HEADERS'],
+        exposedHeaders: env['CORS_EXPOSED_HEADERS'],
         relativeLocation: String(env['PUBLIC_URL']).startsWith('http'),
     });
-    server.on(EVENTS.POST_CREATE, async (_req, res, upload) => {
-        res.setHeader('Directus-File-Id', upload.metadata['id']);
-    });
     return [server, cleanup];
     function cleanup() {
         server.removeAllListeners();

package/dist/telemetry/lib/get-report.js

@@ -7,8 +7,8 @@ import { getExtensionCount } from '../utils/get-extension-count.js';
 import { getFieldCount } from '../utils/get-field-count.js';
 import { getFilesizeSum } from '../utils/get-filesize-sum.js';
 import { getItemCount } from '../utils/get-item-count.js';
+import { getSettings } from '../utils/get-settings.js';
 import { getUserItemCount } from '../utils/get-user-item-count.js';
-import { getProjectId } from '../utils/get-project-id.js';
 const basicCountTasks = [
     { collection: 'directus_dashboards' },
     { collection: 'directus_files' },
@@ -26,7 +26,7 @@ export const getReport = async () => {
     const db = getDatabase();
     const env = useEnv();
     const helpers = getHelpers(db);
-    const [basicCounts, userCounts, userItemCount, fieldsCounts, extensionsCounts, databaseSize, filesizes, projectId] = await Promise.all([
+    const [basicCounts, userCounts, userItemCount, fieldsCounts, extensionsCounts, databaseSize, filesizes, settings] = await Promise.all([
         getItemCount(db, basicCountTasks),
         fetchUserCount({ knex: db }),
         getUserItemCount(db),
@@ -34,7 +34,7 @@ export const getReport = async () => {
         getExtensionCount(db),
         helpers.schema.getDatabaseSize(),
         getFilesizeSum(db),
-        getProjectId(db),
+        getSettings(db),
     ]);
     return {
         url: env['PUBLIC_URL'],
@@ -55,6 +55,6 @@ export const getReport = async () => {
         extensions: extensionsCounts.totalEnabled,
         database_size: databaseSize ?? 0,
         files_size_total: filesizes.total,
-        project_id: projectId,
+        ...settings,
     };
 };

package/dist/telemetry/lib/send-report.d.ts

@@ -1,5 +1,10 @@
 import type { TelemetryReport } from '../types/report.js';
+import type { OwnerInformation } from '@directus/types';
+export type OwnerReport = OwnerInformation & {
+    project_id: string;
+    version: string;
+};
 /**
  * Post an anonymous usage report to the centralized intake server
  */
-export declare const sendReport: (report: TelemetryReport) => Promise<void>;
+export declare const sendReport: (report: TelemetryReport | OwnerReport) => Promise<void>;

package/dist/telemetry/lib/send-report.js

@@ -5,7 +5,9 @@ import { URL } from 'node:url';
  */
 export const sendReport = async (report) => {
     const env = useEnv();
-    const url = new URL('/v1/metrics', env['TELEMETRY_URL']);
+    const url = 'project_owner' in report
+        ? new URL('/v1/owner', String(env['COMPLIANCE_URL']))
+        : new URL('/v1/metrics', String(env['TELEMETRY_URL']));
     const headers = {
         'Content-Type': 'application/json',
     };

package/dist/telemetry/types/report.d.ts

@@ -74,5 +74,21 @@ export interface TelemetryReport {
     /**
      * Unique project identifier
      */
-    project_id?: string | null;
+    project_id: string;
+    /**
+     * Whether the project has enabled MCP
+     */
+    mcp_enabled: boolean;
+    /**
+     * Whether the project allows deletes in MCP
+     */
+    mcp_allow_deletes: boolean;
+    /**
+     * Whether the project has enabled MCP system prompt
+     */
+    mcp_system_prompt_enabled: boolean;
+    /**
+     * Number of Visual Editor URLs configured in the system
+     */
+    visual_editor_urls: number;
 }

package/dist/telemetry/utils/get-settings.d.ts

@@ -0,0 +1,9 @@
+import type { Knex } from 'knex';
+export type TelemetrySettings = {
+    project_id: string;
+    mcp_enabled: boolean;
+    mcp_allow_deletes: boolean;
+    mcp_system_prompt_enabled: boolean;
+    visual_editor_urls: number;
+};
+export declare const getSettings: (db: Knex) => Promise<TelemetrySettings>;

package/dist/telemetry/utils/get-settings.js

@@ -0,0 +1,14 @@
+import { toBoolean } from '@directus/utils';
+export const getSettings = async (db) => {
+    const settings = await db
+        .select('project_id', 'mcp_enabled', 'mcp_allow_deletes', 'mcp_system_prompt_enabled', 'visual_editor_urls')
+        .from('directus_settings')
+        .first();
+    return {
+        project_id: settings.project_id,
+        mcp_enabled: toBoolean(settings?.mcp_enabled),
+        mcp_allow_deletes: toBoolean(settings?.mcp_allow_deletes),
+        mcp_system_prompt_enabled: toBoolean(settings?.mcp_system_prompt_enabled),
+        visual_editor_urls: settings.visual_editor_urls ? JSON.parse(settings.visual_editor_urls).length : 0,
+    };
+};