@directus/api 23.1.2 → 23.2.0

package/dist/schedules/retention.d.ts

@@ -0,0 +1,14 @@
+import type { Knex } from 'knex';
+export interface RetentionTask {
+    collection: string;
+    where?: readonly [string, string, Knex.Value | null];
+    join?: readonly [string, string, string];
+    timeframe: number | undefined;
+}
+export declare function handleRetentionJob(): Promise<void>;
+/**
+ * Schedule the retention tracking
+ *
+ * @returns Whether or not retention has been initialized
+ */
+export default function schedule(): Promise<boolean>;

package/dist/schedules/retention.js

@@ -0,0 +1,96 @@
+import { Action } from '@directus/constants';
+import { useEnv } from '@directus/env';
+import { toBoolean } from '@directus/utils';
+import getDatabase from '../database/index.js';
+import { useLock } from '../lock/index.js';
+import { useLogger } from '../logger/index.js';
+import { getMilliseconds } from '../utils/get-milliseconds.js';
+import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
+const env = useEnv();
+const retentionLockKey = 'schedule--data-retention';
+const retentionLockTimeout = 10 * 60 * 1000; // 10 mins
+const ACTIVITY_RETENTION_TIMEFRAME = getMilliseconds(env['ACTIVITY_RETENTION']);
+const FLOW_LOGS_RETENTION_TIMEFRAME = getMilliseconds(env['FLOW_LOGS_RETENTION']);
+const REVISIONS_RETENTION_TIMEFRAME = getMilliseconds(env['REVISIONS_RETENTION']);
+const retentionTasks = [
+    {
+        collection: 'directus_activity',
+        where: ['action', '!=', Action.RUN],
+        timeframe: ACTIVITY_RETENTION_TIMEFRAME,
+    },
+    {
+        collection: 'directus_activity',
+        where: ['action', '=', Action.RUN],
+        timeframe: FLOW_LOGS_RETENTION_TIMEFRAME,
+    },
+];
+export async function handleRetentionJob() {
+    const database = getDatabase();
+    const logger = useLogger();
+    const lock = useLock();
+    const batch = Number(env['RETENTION_BATCH']);
+    const lockTime = await lock.get(retentionLockKey);
+    const now = Date.now();
+    if (lockTime && Number(lockTime) > now - retentionLockTimeout) {
+        // ensure only one connected process
+        return;
+    }
+    await lock.set(retentionLockKey, Date.now());
+    for (const task of retentionTasks) {
+        let count = 0;
+        if (task.timeframe === undefined) {
+            // skip disabled tasks
+            continue;
+        }
+        do {
+            const subquery = database
+                .queryBuilder()
+                .select(`${task.collection}.id`)
+                .from(task.collection)
+                .where('timestamp', '<', Date.now() - task.timeframe)
+                .limit(batch);
+            if (task.where) {
+                subquery.where(...task.where);
+            }
+            if (task.join) {
+                subquery.join(...task.join);
+            }
+            try {
+                count = await database(task.collection).where('id', 'in', subquery).delete();
+            }
+            catch (error) {
+                logger.error(error, `Retention failed for Collection ${task.collection}`);
+                break;
+            }
+            // Update lock time to prevent concurrent runs
+            await lock.set(retentionLockKey, Date.now());
+        } while (count >= batch);
+    }
+    await lock.delete(retentionLockKey);
+}
+/**
+ * Schedule the retention tracking
+ *
+ * @returns Whether or not retention has been initialized
+ */
+export default async function schedule() {
+    const env = useEnv();
+    if (!toBoolean(env['RETENTION_ENABLED'])) {
+        return false;
+    }
+    if (!validateCron(String(env['RETENTION_SCHEDULE']))) {
+        return false;
+    }
+    if (!ACTIVITY_RETENTION_TIMEFRAME ||
+        (ACTIVITY_RETENTION_TIMEFRAME &&
+            REVISIONS_RETENTION_TIMEFRAME &&
+            ACTIVITY_RETENTION_TIMEFRAME > REVISIONS_RETENTION_TIMEFRAME)) {
+        retentionTasks.push({
+            collection: 'directus_revisions',
+            join: ['directus_activity', 'directus_revisions.activity', 'directus_activity.id'],
+            timeframe: REVISIONS_RETENTION_TIMEFRAME,
+        });
+    }
+    scheduleSynchronizedJob('retention', String(env['RETENTION_SCHEDULE']), handleRetentionJob);
+    return true;
+}

package/dist/{telemetry/lib/init-telemetry.d.ts → schedules/telemetry.d.ts}

@@ -3,9 +3,9 @@
  */
 export declare const jobCallback: () => void;
 /**
- * Initialize the telemetry tracking. Will generate a report on start, and set a schedule to report
+ * Schedule the telemetry tracking. Will generate a report on start, and set a schedule to report
  * every 6 hours
  *
  * @returns Whether or not telemetry has been initialized
  */
-export declare const initTelemetry: () => Promise<boolean>;
+export default function schedule(): Promise<boolean>;

package/dist/{telemetry/lib/init-telemetry.js → schedules/telemetry.js}

@@ -1,8 +1,8 @@
 import { useEnv } from '@directus/env';
 import { toBoolean } from '@directus/utils';
-import { getCache } from '../../cache.js';
-import { scheduleSynchronizedJob } from '../../utils/schedule.js';
-import { track } from './track.js';
+import { getCache } from '../cache.js';
+import { scheduleSynchronizedJob } from '../utils/schedule.js';
+import { track } from '../telemetry/index.js';
 /**
  * Exported to be able to test the anonymous callback function
  */
@@ -10,12 +10,12 @@ export const jobCallback = () => {
     track();
 };
 /**
- * Initialize the telemetry tracking. Will generate a report on start, and set a schedule to report
+ * Schedule the telemetry tracking. Will generate a report on start, and set a schedule to report
  * every 6 hours
  *
  * @returns Whether or not telemetry has been initialized
  */
-export const initTelemetry = async () => {
+export default async function schedule() {
     const env = useEnv();
     if (toBoolean(env['TELEMETRY']) === false)
         return false;
@@ -27,4 +27,4 @@ export const initTelemetry = async () => {
         // Don't flush the lock. We want to debounce these calls across containers on startup
     }
     return true;
-};
+}

package/dist/schedules/tus.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Schedule the tus cleanup
+ *
+ * @returns Whether or not tus cleanup has been initialized
+ */
+export default function schedule(): Promise<boolean>;

package/dist/schedules/tus.js

@@ -0,0 +1,23 @@
+import { RESUMABLE_UPLOADS } from '../constants.js';
+import { getSchema } from '../utils/get-schema.js';
+import { createTusServer } from '../services/tus/index.js';
+import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
+/**
+ * Schedule the tus cleanup
+ *
+ * @returns Whether or not tus cleanup has been initialized
+ */
+export default async function schedule() {
+    if (!RESUMABLE_UPLOADS.ENABLED)
+        return false;
+    if (validateCron(RESUMABLE_UPLOADS.SCHEDULE)) {
+        scheduleSynchronizedJob('tus-cleanup', RESUMABLE_UPLOADS.SCHEDULE, async () => {
+            const [tusServer, cleanupServer] = await createTusServer({
+                schema: await getSchema(),
+            });
+            await tusServer.cleanUpExpiredUploads();
+            cleanupServer();
+        });
+    }
+    return true;
+}

package/dist/services/assets.js

@@ -87,6 +87,8 @@ export class AssetsService {
         }
         const type = file.type;
         const transforms = transformation ? TransformationUtils.resolvePreset(transformation, file) : [];
+        const modifiedOn = file.modified_on ? new Date(file.modified_on) : undefined;
+        const version = modifiedOn ? (modifiedOn.getTime() / 1000).toFixed() : undefined;
         if (type && transforms.length > 0 && SUPPORTED_IMAGE_TRANSFORM_FORMATS.includes(type)) {
             const maybeNewFormat = TransformationUtils.maybeExtractFormat(transforms);
             const assetFilename = path.basename(file.filename_disk, path.extname(file.filename_disk)) +
@@ -121,7 +123,6 @@ export class AssetsService {
                     reason: 'Server too busy',
                 });
             }
-            const version = file.modified_on !== undefined ? String(Math.round(new Date(file.modified_on).getTime() / 1000)) : undefined;
             const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
             const transformer = getSharpInstance();
             transformer.timeout({
@@ -152,13 +153,13 @@ export class AssetsService {
                 }
             }
             return {
-                stream: await storage.location(file.storage).read(assetFilename, { range }),
+                stream: await storage.location(file.storage).read(assetFilename, { range, version }),
                 stat: await storage.location(file.storage).stat(assetFilename),
                 file,
             };
         }
         else {
-            const readStream = await storage.location(file.storage).read(file.filename_disk, { range });
+            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
             const stat = await storage.location(file.storage).stat(file.filename_disk);
             return { stream: readStream, file, stat };
         }

package/dist/services/comments.d.ts

@@ -1,31 +1,13 @@
-import type { Comment, Item, PrimaryKey, Query } from '@directus/types';
+import type { Comment, PrimaryKey } from '@directus/types';
 import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
-import { ActivityService } from './activity.js';
-import { ItemsService, type QueryOptions } from './items.js';
+import { ItemsService } from './items.js';
 import { NotificationsService } from './notifications.js';
 import { UsersService } from './users.js';
-type serviceOrigin = 'activity' | 'comments';
 export declare class CommentsService extends ItemsService {
-    activityService: ActivityService;
     notificationsService: NotificationsService;
     usersService: UsersService;
-    serviceOrigin: serviceOrigin;
-    constructor(options: AbstractServiceOptions & {
-        serviceOrigin: serviceOrigin;
-    });
-    readOne(key: PrimaryKey, query?: Query, opts?: QueryOptions): Promise<Item>;
-    readByQuery(query: Query, opts?: QueryOptions): Promise<Item[]>;
-    readMany(keys: PrimaryKey[], query?: Query, opts?: QueryOptions): Promise<Item[]>;
+    constructor(options: AbstractServiceOptions);
     createOne(data: Partial<Comment>, opts?: MutationOptions): Promise<PrimaryKey>;
-    updateByQuery(query: Query, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
-    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
-    updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
-    deleteByQuery(query: Query, opts?: MutationOptions): Promise<PrimaryKey[]>;
-    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateOne(key: PrimaryKey, data: Partial<Comment>, opts?: MutationOptions): Promise<PrimaryKey>;
     deleteOne(key: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
-    private processPrimaryKeys;
-    migrateLegacyComment(activityPk: PrimaryKey): Promise<PrimaryKey>;
-    generateQuery(type: serviceOrigin, originalQuery: Query): Query;
-    private sortLegacyResults;
 }
-export {};

package/dist/services/comments.js

@@ -1,96 +1,29 @@
-import { Action } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { ErrorCode, ForbiddenError, InvalidPayloadError, isDirectusError } from '@directus/errors';
-import { cloneDeep, mergeWith, uniq } from 'lodash-es';
-import { randomUUID } from 'node:crypto';
+import { uniq } from 'lodash-es';
 import { useLogger } from '../logger/index.js';
 import { fetchRolesTree } from '../permissions/lib/fetch-roles-tree.js';
 import { fetchGlobalAccess } from '../permissions/modules/fetch-global-access/fetch-global-access.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 import { isValidUuid } from '../utils/is-valid-uuid.js';
-import { transaction } from '../utils/transaction.js';
 import { Url } from '../utils/url.js';
 import { userName } from '../utils/user-name.js';
-import { ActivityService } from './activity.js';
 import { ItemsService } from './items.js';
 import { NotificationsService } from './notifications.js';
 import { UsersService } from './users.js';
 const env = useEnv();
 const logger = useLogger();
-// TODO: Remove legacy comments logic
 export class CommentsService extends ItemsService {
-    activityService;
     notificationsService;
     usersService;
-    serviceOrigin;
     constructor(options) {
         super('directus_comments', options);
-        this.activityService = new ActivityService(options);
         this.notificationsService = new NotificationsService({ schema: this.schema });
         this.usersService = new UsersService({ schema: this.schema });
-        this.serviceOrigin = options.serviceOrigin ?? 'comments';
-    }
-    readOne(key, query, opts) {
-        const isLegacyComment = isNaN(Number(key));
-        let result;
-        if (isLegacyComment) {
-            const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query || {});
-            result = this.activityService.readOne(key, activityQuery, opts);
-        }
-        else {
-            const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query || {});
-            result = super.readOne(key, commentsQuery, opts);
-        }
-        return result;
-    }
-    async readByQuery(query, opts) {
-        const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query);
-        const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query);
-        const activityResult = await this.activityService.readByQuery(activityQuery, opts);
-        const commentsResult = await super.readByQuery(commentsQuery, opts);
-        if (query.aggregate) {
-            // Merging the first result only as the app does not utilise group
-            return [
-                mergeWith({}, activityResult[0], commentsResult[0], (a, b) => {
-                    const numA = Number(a);
-                    const numB = Number(b);
-                    if (!isNaN(numA) && !isNaN(numB)) {
-                        return numA + numB;
-                    }
-                    return;
-                }),
-            ];
-        }
-        else if (query.sort) {
-            return this.sortLegacyResults([...activityResult, ...commentsResult], query.sort);
-        }
-        else {
-            return [...activityResult, ...commentsResult];
-        }
-    }
-    async readMany(keys, query, opts) {
-        const commentsKeys = [];
-        const activityKeys = [];
-        for (const key of keys) {
-            if (isNaN(Number(key))) {
-                commentsKeys.push(key);
-            }
-            else {
-                activityKeys.push(key);
-            }
-        }
-        const activityQuery = this.serviceOrigin === 'activity' ? query : this.generateQuery('activity', query || {});
-        const commentsQuery = this.serviceOrigin === 'comments' ? query : this.generateQuery('comments', query || {});
-        const activityResult = await this.activityService.readMany(activityKeys, activityQuery, opts);
-        const commentsResult = await super.readMany(commentsKeys, commentsQuery, opts);
-        if (query?.sort) {
-            return this.sortLegacyResults([...activityResult, ...commentsResult], query.sort);
-        }
-        else {
-            return [...activityResult, ...commentsResult];
-        }
     }
     async createOne(data, opts) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
         if (!data['comment']) {
             throw new InvalidPayloadError({ reason: `"comment" is required` });
         }
@@ -111,8 +44,12 @@ export class CommentsService extends ItemsService {
                 knex: this.knex,
             });
         }
+        const result = await super.createOne(data, opts);
         const usersRegExp = new RegExp(/@[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/gi);
         const mentions = uniq(data['comment'].match(usersRegExp) ?? []);
+        if (mentions.length === 0) {
+            return result;
+        }
         const sender = await this.usersService.readOne(this.accountability.user, {
             fields: ['id', 'first_name', 'last_name', 'email'],
         });
@@ -190,189 +127,16 @@ ${comment}
                 }
             }
         }
-        return super.createOne(data, opts);
-    }
-    async updateByQuery(query, data, opts) {
-        const keys = await this.getKeysByQuery(query);
-        const migratedKeys = await this.processPrimaryKeys(keys);
-        return super.updateMany(migratedKeys, data, opts);
-    }
-    async updateMany(keys, data, opts) {
-        const migratedKeys = await this.processPrimaryKeys(keys);
-        return super.updateMany(migratedKeys, data, opts);
-    }
-    async updateOne(key, data, opts) {
-        const migratedKey = await this.migrateLegacyComment(key);
-        return super.updateOne(migratedKey, data, opts);
-    }
-    async deleteByQuery(query, opts) {
-        const keys = await this.getKeysByQuery(query);
-        const migratedKeys = await this.processPrimaryKeys(keys);
-        return super.deleteMany(migratedKeys, opts);
-    }
-    async deleteMany(keys, opts) {
-        const migratedKeys = await this.processPrimaryKeys(keys);
-        return super.deleteMany(migratedKeys, opts);
-    }
-    async deleteOne(key, opts) {
-        const migratedKey = await this.migrateLegacyComment(key);
-        return super.deleteOne(migratedKey, opts);
-    }
-    async processPrimaryKeys(keys) {
-        const migratedKeys = [];
-        for (const key of keys) {
-            if (isNaN(Number(key))) {
-                migratedKeys.push(key);
-                continue;
-            }
-            migratedKeys.push(await this.migrateLegacyComment(key));
-        }
-        return migratedKeys;
-    }
-    async migrateLegacyComment(activityPk) {
-        // Skip migration if not a legacy comment
-        if (isNaN(Number(activityPk))) {
-            return activityPk;
-        }
-        return transaction(this.knex, async (trx) => {
-            let primaryKey;
-            const legacyComment = await trx('directus_activity').select('*').where('id', '=', activityPk).first();
-            // Legacy comment
-            if (legacyComment['action'] === Action.COMMENT) {
-                primaryKey = randomUUID();
-                await trx('directus_comments').insert({
-                    id: primaryKey,
-                    collection: legacyComment.collection,
-                    item: legacyComment.item,
-                    comment: legacyComment.comment,
-                    user_created: legacyComment.user,
-                    date_created: legacyComment.timestamp,
-                });
-                await trx('directus_activity')
-                    .update({
-                    action: Action.CREATE,
-                    collection: 'directus_comments',
-                    item: primaryKey,
-                    comment: null,
-                })
-                    .where('id', '=', activityPk);
-            }
-            // Migrated comment
-            else if (legacyComment.collection === 'directus_comment' && legacyComment.action === Action.CREATE) {
-                primaryKey = legacyComment.item;
-            }
-            if (!primaryKey) {
-                throw new ForbiddenError();
-            }
-            return primaryKey;
-        });
+        return result;
     }
-    generateQuery(type, originalQuery) {
-        const query = cloneDeep(originalQuery);
-        const defaultActivityCommentFilter = { action: { _eq: Action.COMMENT } };
-        const commentsToActivityFieldMap = {
-            id: 'id',
-            comment: 'comment',
-            item: 'item',
-            collection: 'collection',
-            user_created: 'user',
-            date_created: 'timestamp',
-        };
-        const activityToCommentsFieldMap = {
-            id: 'id',
-            comment: 'comment',
-            item: 'item',
-            collection: 'collection',
-            user: 'user_created',
-            timestamp: 'date_created',
-        };
-        const targetFieldMap = type === 'activity' ? commentsToActivityFieldMap : activityToCommentsFieldMap;
-        for (const key of Object.keys(originalQuery)) {
-            switch (key) {
-                case 'fields':
-                    if (!originalQuery.fields)
-                        break;
-                    query.fields = [];
-                    for (const field of originalQuery.fields) {
-                        if (field === '*') {
-                            query.fields = ['*'];
-                            break;
-                        }
-                        const parts = field.split('.');
-                        const firstPart = parts[0];
-                        if (firstPart && targetFieldMap[firstPart]) {
-                            query.fields.push(field);
-                            if (firstPart !== targetFieldMap[firstPart]) {
-                                (query.alias = query.alias || {})[firstPart] = targetFieldMap[firstPart];
-                            }
-                        }
-                    }
-                    break;
-                case 'filter':
-                    if (!originalQuery.filter)
-                        break;
-                    if (type === 'activity') {
-                        query.filter = { _and: [defaultActivityCommentFilter, originalQuery.filter] };
-                    }
-                    if (type === 'comments' && this.serviceOrigin === 'activity') {
-                        if ('_and' in originalQuery.filter && Array.isArray(originalQuery.filter['_and'])) {
-                            query.filter = {
-                                _and: originalQuery.filter['_and'].filter((andItem) => !('action' in andItem && '_eq' in andItem['action'] && andItem['action']['_eq'] === 'comment')),
-                            };
-                        }
-                        else {
-                            query.filter = originalQuery.filter;
-                        }
-                    }
-                    break;
-                case 'aggregate':
-                    if (originalQuery.aggregate) {
-                        query.aggregate = originalQuery.aggregate;
-                    }
-                    break;
-                case 'sort':
-                    if (!originalQuery.sort)
-                        break;
-                    query.sort = [];
-                    for (const sort of originalQuery.sort) {
-                        const isDescending = sort.startsWith('-');
-                        const field = isDescending ? sort.slice(1) : sort;
-                        if (field && targetFieldMap[field]) {
-                            query.sort.push(`${isDescending ? '-' : ''}${targetFieldMap[field]}`);
-                        }
-                    }
-                    break;
-            }
-        }
-        if (type === 'activity' && !query.filter) {
-            query.filter = defaultActivityCommentFilter;
-        }
-        return query;
+    updateOne(key, data, opts) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
+        return super.updateOne(key, data, opts);
     }
-    sortLegacyResults(results, sort) {
-        if (!sort)
-            return results;
-        let sortKeys = sort;
-        // Fix legacy app sort query which uses id
-        if (sortKeys.length === 1 && sortKeys[0]?.endsWith('id') && results[0]?.['timestamp']) {
-            sortKeys = [`${sortKeys[0].startsWith('-') ? '-' : ''}timestamp`];
-        }
-        return results.sort((a, b) => {
-            for (const key of sortKeys) {
-                const isDescending = key.startsWith('-');
-                const actualKey = isDescending ? key.substring(1) : key;
-                let aValue = a[actualKey];
-                let bValue = b[actualKey];
-                if (actualKey === 'date_created' || actualKey === 'timestamp') {
-                    aValue = new Date(aValue);
-                    bValue = new Date(bValue);
-                }
-                if (aValue < bValue)
-                    return isDescending ? 1 : -1;
-                if (aValue > bValue)
-                    return isDescending ? -1 : 1;
-            }
-            return 0;
-        });
+    deleteOne(key, opts) {
+        if (!this.accountability?.user)
+            throw new ForbiddenError();
+        return super.deleteOne(key, opts);
     }
 }

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

@@ -67,11 +67,10 @@ export declare class GraphQLService {
      * Effectively merges the selections with the fragments used in those selections
      */
     replaceFragmentsInSelections(selections: readonly SelectionNode[] | undefined, fragments: Record<string, FragmentDefinitionNode>): readonly SelectionNode[] | null;
-    injectSystemResolvers(schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes, }: {
+    injectSystemResolvers(schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, }: {
         CreateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
         ReadCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
         UpdateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
-        DeleteCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
     }, schema: {
         create: SchemaOverview;
         read: SchemaOverview;