@directus/api 30.0.0 → 32.0.0

package/dist/services/items.js

@@ -8,7 +8,7 @@ import { getCache } from '../cache.js';
 import { translateDatabaseError } from '../database/errors/translate.js';
 import { getAstFromQuery } from '../database/get-ast-from-query/get-ast-from-query.js';
 import { getHelpers } from '../database/helpers/index.js';
-import getDatabase from '../database/index.js';
+import getDatabase, { getDatabaseClient } from '../database/index.js';
 import { runAst } from '../database/run-ast/run-ast.js';
 import emitter from '../emitter.js';
 import { processAst } from '../permissions/modules/process-ast/process-ast.js';
@@ -148,6 +148,7 @@ export class ItemsService {
                 knex: trx,
                 schema: this.schema,
                 nested: this.nested,
+                overwriteDefaults: opts.overwriteDefaults,
             });
             const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, userIntegrityCheckFlags: userIntegrityCheckFlagsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
             const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, userIntegrityCheckFlags: userIntegrityCheckFlagsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
@@ -172,10 +173,15 @@ export class ItemsService {
                 autoIncrementSequenceNeedsToBeReset = true;
             }
             try {
+                let returningOptions = undefined;
+                // Support MSSQL tables that have triggers.
+                if (getDatabaseClient(trx) === 'mssql') {
+                    returningOptions = { includeTriggerModifications: true };
+                }
                 const result = await trx
                     .insert(payloadWithoutAliases)
                     .into(this.collection)
-                    .returning(primaryKeyField)
+                    .returning(primaryKeyField, returningOptions)
                     .then((result) => result[0]);
                 const returnedKey = typeof result === 'object' ? result[primaryKeyField] : result;
                 if (pkField.type === 'uuid') {
@@ -338,6 +344,7 @@ export class ItemsService {
                     onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                     bypassEmitAction: (params) => nestedActionEvents.push(params),
                     mutationTracker: opts.mutationTracker,
+                    overwriteDefaults: opts.overwriteDefaults?.[index],
                     bypassAutoIncrementSequenceReset,
                 });
                 primaryKeys.push(primaryKey);
@@ -434,8 +441,8 @@ export class ItemsService {
         const filterWithKey = assign({}, query.filter, { [primaryKeyField]: { _eq: key } });
         const queryWithKey = assign({}, query, { filter: filterWithKey });
         let results = [];
-        if (query.version) {
-            results = (await handleVersion(this, key, queryWithKey, opts));
+        if (query.version && query.version !== 'main') {
+            results = [await handleVersion(this, key, queryWithKey, opts)];
         }
         else {
             results = await this.readByQuery(queryWithKey, opts);
@@ -497,13 +504,15 @@ export class ItemsService {
             await transaction(this.knex, async (knex) => {
                 const service = this.fork({ knex });
                 let userIntegrityCheckFlags = opts.userIntegrityCheckFlags ?? UserIntegrityCheckFlag.None;
-                for (const item of data) {
+                for (const index in data) {
+                    const item = data[index];
                     const primaryKey = item[primaryKeyField];
                     if (!primaryKey)
                         throw new InvalidPayloadError({ reason: `Item in update misses primary key` });
                     const combinedOpts = {
                         autoPurgeCache: false,
                         ...opts,
+                        overwriteDefaults: opts.overwriteDefaults?.[index],
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                     };
                     keys.push(await service.updateOne(primaryKey, omit(item, primaryKeyField), combinedOpts));
@@ -591,6 +600,7 @@ export class ItemsService {
                 knex: trx,
                 schema: this.schema,
                 nested: this.nested,
+                overwriteDefaults: opts.overwriteDefaults,
             });
             const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, userIntegrityCheckFlags: userIntegrityCheckFlagsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
             const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, userIntegrityCheckFlags: userIntegrityCheckFlagsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
@@ -752,8 +762,13 @@ export class ItemsService {
         const primaryKeys = await transaction(this.knex, async (knex) => {
             const service = this.fork({ knex });
             const primaryKeys = [];
-            for (const payload of payloads) {
-                const primaryKey = await service.upsertOne(payload, { ...(opts || {}), autoPurgeCache: false });
+            for (const index in payloads) {
+                const payload = payloads[index];
+                const primaryKey = await service.upsertOne(payload, {
+                    ...(opts || {}),
+                    overwriteDefaults: opts.overwriteDefaults?.[index],
+                    autoPurgeCache: false,
+                });
                 primaryKeys.push(primaryKey);
             }
             return primaryKeys;
@@ -796,12 +811,23 @@ export class ItemsService {
         }
         const primaryKeyField = this.schema.collections[this.collection].primary;
         validateKeys(this.schema, this.collection, primaryKeyField, keys);
+        const keysAfterHooks = opts.emitEvents !== false
+            ? await emitter.emitFilter(this.eventScope === 'items'
+                ? ['items.delete', `${this.collection}.items.delete`]
+                : `${this.eventScope}.delete`, keys, {
+                collection: this.collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            })
+            : keys;
         if (this.accountability) {
             await validateAccess({
                 accountability: this.accountability,
                 action: 'delete',
                 collection: this.collection,
-                primaryKeys: keys,
+                primaryKeys: keysAfterHooks,
             }, {
                 knex: this.knex,
                 schema: this.schema,
@@ -810,17 +836,8 @@ export class ItemsService {
         if (opts.preMutationError) {
             throw opts.preMutationError;
         }
-        if (opts.emitEvents !== false) {
-            await emitter.emitFilter(this.eventScope === 'items' ? ['items.delete', `${this.collection}.items.delete`] : `${this.eventScope}.delete`, keys, {
-                collection: this.collection,
-            }, {
-                database: this.knex,
-                schema: this.schema,
-                accountability: this.accountability,
-            });
-        }
         await transaction(this.knex, async (trx) => {
-            await trx(this.collection).whereIn(primaryKeyField, keys).delete();
+            await trx(this.collection).whereIn(primaryKeyField, keysAfterHooks).delete();
             if (opts.userIntegrityCheckFlags) {
                 if (opts.onRequireUserIntegrityCheck) {
                     opts.onRequireUserIntegrityCheck(opts.userIntegrityCheckFlags);
@@ -837,7 +854,7 @@ export class ItemsService {
                     knex: trx,
                     schema: this.schema,
                 });
-                await activityService.createMany(keys.map((key) => ({
+                await activityService.createMany(keysAfterHooks.map((key) => ({
                     action: Action.DELETE,
                     user: this.accountability.user,
                     collection: this.collection,
@@ -857,8 +874,8 @@ export class ItemsService {
                     ? ['items.delete', `${this.collection}.items.delete`]
                     : `${this.eventScope}.delete`,
                 meta: {
-                    payload: keys,
-                    keys: keys,
+                    payload: keysAfterHooks,
+                    keys: keysAfterHooks,
                     collection: this.collection,
                 },
                 context: {
@@ -874,7 +891,7 @@ export class ItemsService {
                 emitter.emitAction(actionEvent.event, actionEvent.meta, actionEvent.context);
             }
         }
-        return keys;
+        return keysAfterHooks;
     }
     /**
      * Read/treat collection as singleton.
@@ -882,8 +899,17 @@ export class ItemsService {
     async readSingleton(query, opts) {
         query = clone(query);
         query.limit = 1;
-        const records = await this.readByQuery(query, opts);
-        const record = records[0];
+        let record;
+        if (query.version && query.version !== 'main') {
+            const primaryKeyField = this.schema.collections[this.collection].primary;
+            const key = (await this.knex.select(primaryKeyField).from(this.collection).first())?.[primaryKeyField];
+            if (key) {
+                record = await handleVersion(this, key, query, opts);
+            }
+        }
+        else {
+            record = (await this.readByQuery(query, opts))[0];
+        }
         if (!record) {
             let fields = Object.entries(this.schema.collections[this.collection].fields);
             const defaults = {};

package/dist/services/mail/index.js

@@ -10,6 +10,7 @@ import emitter from '../../emitter.js';
 import { useLogger } from '../../logger/index.js';
 import getMailer from '../../mailer.js';
 import { Url } from '../../utils/url.js';
+import { useEmailRateLimiterQueue } from './rate-limiter.js';
 const env = useEnv();
 const logger = useLogger();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -37,6 +38,7 @@ export class MailService {
         }
     }
     async send(options) {
+        await useEmailRateLimiterQueue();
         const payload = await emitter.emitFilter(`email.send`, options, {});
         if (!payload)
             return null;

package/dist/services/mail/rate-limiter.d.ts

@@ -0,0 +1 @@
+export declare function useEmailRateLimiterQueue(): Promise<void>;

package/dist/services/mail/rate-limiter.js

@@ -0,0 +1,29 @@
+import { useEnv } from '@directus/env';
+import { RateLimiterQueue } from 'rate-limiter-flexible';
+import { createRateLimiter } from '../../rate-limiter.js';
+import { toBoolean } from '@directus/utils';
+import { EmailLimitExceededError } from '@directus/errors';
+let emailRateLimiterQueue;
+const env = useEnv();
+if (toBoolean(env['RATE_LIMITER_EMAIL_ENABLED']) === true) {
+    emailRateLimiterQueue = new RateLimiterQueue(createRateLimiter('RATE_LIMITER_EMAIL'), {
+        maxQueueSize: Number(env['RATE_LIMITER_EMAIL_QUEUE_SIZE']),
+    });
+}
+export async function useEmailRateLimiterQueue() {
+    if (!emailRateLimiterQueue)
+        return;
+    try {
+        await emailRateLimiterQueue.removeTokens(1);
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new EmailLimitExceededError({
+                points: 'RATE_LIMITER_EMAIL_POINTS' in env ? Number(env['RATE_LIMITER_EMAIL_POINTS']) : undefined,
+                duration: 'RATE_LIMITER_EMAIL_DURATION' in env ? Number(env['RATE_LIMITER_EMAIL_DURATION']) : undefined,
+                message: 'RATE_LIMITER_EMAIL_ERROR_MESSAGE' in env ? String(env['RATE_LIMITER_EMAIL_ERROR_MESSAGE']) : undefined,
+            });
+        }
+        throw err;
+    }
+}

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/payload.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractServiceOptions, Accountability, Aggregate, FieldOverview, Item, MutationOptions, PayloadAction, PayloadServiceProcessRelationResult, PrimaryKey, SchemaOverview } from '@directus/types';
+import type { AbstractServiceOptions, Accountability, Aggregate, DefaultOverwrite, FieldOverview, Item, MutationOptions, PayloadAction, PayloadServiceProcessRelationResult, PrimaryKey, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Helpers } from '../database/helpers/index.js';
 type Transformers = {
@@ -9,6 +9,7 @@ type Transformers = {
         accountability: Accountability | null;
         specials: string[];
         helpers: Helpers;
+        overwriteDefaults: DefaultOverwrite | undefined;
     }) => Promise<any>;
 };
 /**
@@ -22,7 +23,10 @@ export declare class PayloadService {
     collection: string;
     schema: SchemaOverview;
     nested: string[];
-    constructor(collection: string, options: AbstractServiceOptions);
+    overwriteDefaults: DefaultOverwrite | undefined;
+    constructor(collection: string, options: AbstractServiceOptions & {
+        overwriteDefaults?: DefaultOverwrite | undefined;
+    });
     transformers: Transformers;
     processValues(action: PayloadAction, payloads: Partial<Item>[]): Promise<Partial<Item>[]>;
     processValues(action: PayloadAction, payload: Partial<Item>): Promise<Partial<Item>>;
@@ -62,6 +66,6 @@ export declare class PayloadService {
      * Transforms the input partial payload to match the output structure, to have consistency
      * between delta and data
      */
-    prepareDelta(data: Partial<Item>): Promise<string | null>;
+    prepareDelta(delta: Partial<Item>): Promise<string | null>;
 }
 export {};

package/dist/services/payload.js

@@ -21,6 +21,7 @@ export class PayloadService {
     collection;
     schema;
     nested;
+    overwriteDefaults;
     constructor(collection, options) {
         this.accountability = options.accountability || null;
         this.knex = options.knex || getDatabase();
@@ -28,6 +29,7 @@ export class PayloadService {
         this.collection = collection;
         this.schema = options.schema;
         this.nested = options.nested ?? [];
+        this.overwriteDefaults = options.overwriteDefaults;
         return this;
     }
     transformers = {
@@ -77,14 +79,14 @@ export class PayloadService {
                 return value ? '**********' : null;
             return value;
         },
-        async 'user-created'({ action, value, accountability }) {
+        async 'user-created'({ action, value, accountability, overwriteDefaults }) {
             if (action === 'create')
-                return accountability?.user || null;
+                return (overwriteDefaults ? overwriteDefaults._user : accountability?.user) ?? null;
             return value;
         },
-        async 'user-updated'({ action, value, accountability }) {
+        async 'user-updated'({ action, value, accountability, overwriteDefaults }) {
             if (action === 'update')
-                return accountability?.user || null;
+                return (overwriteDefaults ? overwriteDefaults._user : accountability?.user) ?? null;
             return value;
         },
         async 'role-created'({ action, value, accountability }) {
@@ -97,14 +99,14 @@ export class PayloadService {
                 return accountability?.role || null;
             return value;
         },
-        async 'date-created'({ action, value, helpers }) {
+        async 'date-created'({ action, value, helpers, overwriteDefaults }) {
             if (action === 'create')
-                return new Date(helpers.date.writeTimestamp(new Date().toISOString()));
+                return new Date(overwriteDefaults ? overwriteDefaults._date : helpers.date.writeTimestamp(new Date().toISOString()));
             return value;
         },
-        async 'date-updated'({ action, value, helpers }) {
+        async 'date-updated'({ action, value, helpers, overwriteDefaults }) {
             if (action === 'update')
-                return new Date(helpers.date.writeTimestamp(new Date().toISOString()));
+                return new Date(overwriteDefaults ? overwriteDefaults._date : helpers.date.writeTimestamp(new Date().toISOString()));
             return value;
         },
         async 'cast-csv'({ action, value }) {
@@ -212,6 +214,7 @@ export class PayloadService {
                     accountability,
                     specials: fieldSpecials,
                     helpers: this.helpers,
+                    overwriteDefaults: this.overwriteDefaults,
                 });
             }
         }
@@ -405,6 +408,7 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
@@ -419,6 +423,7 @@ export class PayloadService {
                     autoPurgeCache: opts?.autoPurgeCache,
                     autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                     skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
                     onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 });
@@ -479,6 +484,7 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
@@ -493,6 +499,7 @@ export class PayloadService {
                     autoPurgeCache: opts?.autoPurgeCache,
                     autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                     skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.field],
                     onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 });
@@ -589,6 +596,7 @@ export class PayloadService {
                     autoPurgeCache: opts?.autoPurgeCache,
                     autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                     skipTracking: opts?.skipTracking,
+                    overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
                     onItemCreate: opts?.onItemCreate,
                     mutationTracker: opts?.mutationTracker,
                 })));
@@ -619,6 +627,7 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
@@ -632,6 +641,7 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
@@ -679,13 +689,14 @@ export class PayloadService {
                         autoPurgeCache: opts?.autoPurgeCache,
                         autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                         skipTracking: opts?.skipTracking,
+                        overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['create'],
                         onItemCreate: opts?.onItemCreate,
                         mutationTracker: opts?.mutationTracker,
                     });
                 }
                 if (alterations.update) {
-                    for (const item of alterations.update) {
-                        const { [relatedPrimaryKeyField]: key, ...record } = item;
+                    for (const index in alterations.update) {
+                        const { [relatedPrimaryKeyField]: key, ...record } = alterations.update[index];
                         const existingRecord = await this.knex
                             .select(relatedPrimaryKeyField, relation.field)
                             .from(relation.collection)
@@ -702,6 +713,7 @@ export class PayloadService {
                             autoPurgeCache: opts?.autoPurgeCache,
                             autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                             skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['update'][index],
                             onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
@@ -733,6 +745,7 @@ export class PayloadService {
                             autoPurgeCache: opts?.autoPurgeCache,
                             autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                             skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['delete'],
                             onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
@@ -746,6 +759,7 @@ export class PayloadService {
                             autoPurgeCache: opts?.autoPurgeCache,
                             autoPurgeSystemCache: opts?.autoPurgeSystemCache,
                             skipTracking: opts?.skipTracking,
+                            overwriteDefaults: opts?.overwriteDefaults?.[relation.meta.one_field]?.['delete'],
                             onItemCreate: opts?.onItemCreate,
                             mutationTracker: opts?.mutationTracker,
                         });
@@ -759,8 +773,8 @@ export class PayloadService {
      * Transforms the input partial payload to match the output structure, to have consistency
      * between delta and data
      */
-    async prepareDelta(data) {
-        let payload = cloneDeep(data);
+    async prepareDelta(delta) {
+        let payload = cloneDeep(delta);
         for (const key in payload) {
             if (payload[key]?.isRawInstance) {
                 payload[key] = payload[key].bindings[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',
@@ -53,6 +57,8 @@ 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'] = {
@@ -111,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() {
@@ -221,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';
@@ -255,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';
@@ -291,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';
@@ -326,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/tfa.d.ts

@@ -6,7 +6,7 @@ export declare class TFAService {
     itemsService: ItemsService;
     constructor(options: AbstractServiceOptions);
     verifyOTP(key: PrimaryKey, otp: string, secret?: string): Promise<boolean>;
-    generateTFA(key: PrimaryKey): Promise<Record<string, string>>;
+    generateTFA(key: PrimaryKey, requiresPassword?: boolean): Promise<Record<string, string>>;
     enableTFA(key: PrimaryKey, otp: string, secret: string): Promise<void>;
     disableTFA(key: PrimaryKey): Promise<void>;
 }