@directus/api 23.1.3 → 23.2.1

package/dist/app.js

@@ -38,11 +38,14 @@ import serverRouter from './controllers/server.js';
 import settingsRouter from './controllers/settings.js';
 import sharesRouter from './controllers/shares.js';
 import translationsRouter from './controllers/translations.js';
-import { default as tusRouter, scheduleTusCleanup } from './controllers/tus.js';
+import tusRouter from './controllers/tus.js';
 import usersRouter from './controllers/users.js';
 import utilsRouter from './controllers/utils.js';
 import versionsRouter from './controllers/versions.js';
 import webhooksRouter from './controllers/webhooks.js';
+import retentionSchedule from './schedules/retention.js';
+import telemetrySchedule from './schedules/telemetry.js';
+import tusSchedule from './schedules/tus.js';
 import { isInstalled, validateDatabaseConnection, validateDatabaseExtensions, validateMigrations, } from './database/index.js';
 import emitter from './emitter.js';
 import { getExtensionManager } from './extensions/index.js';
@@ -57,7 +60,6 @@ import rateLimiterGlobal from './middleware/rate-limiter-global.js';
 import rateLimiter from './middleware/rate-limiter-ip.js';
 import sanitizeQuery from './middleware/sanitize-query.js';
 import schema from './middleware/schema.js';
-import { initTelemetry } from './telemetry/index.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { Url } from './utils/url.js';
 import { validateStorage } from './utils/validate-storage.js';
@@ -246,8 +248,9 @@ export default async function createApp() {
     app.use(notFoundHandler);
     app.use(errorHandler);
     await emitter.emitInit('routes.after', { app });
-    initTelemetry();
-    scheduleTusCleanup();
+    await retentionSchedule();
+    await telemetrySchedule();
+    await tusSchedule();
     await emitter.emitInit('app.after', { app });
     return app;
 }

package/dist/auth/drivers/openid.js

@@ -259,7 +259,7 @@ export function createOpenIDAuthRouter(providerName) {
             throw new InvalidPayloadError({ reason: `URL "${redirect}" can't be used to redirect after login` });
         }
         const token = jwt.sign({ verifier: codeVerifier, redirect, prompt }, getSecret(), {
-            expiresIn: '5m',
+            expiresIn: (env[`AUTH_${providerName.toUpperCase()}_LOGIN_TIMEOUT`] ?? '5m'),
             issuer: 'directus',
         });
         res.cookie(`openid.${providerName}`, token, {

package/dist/controllers/activity.js

@@ -1,11 +1,8 @@
-import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import express from 'express';
-import Joi from 'joi';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
 import { ActivityService } from '../services/activity.js';
-import { CommentsService } from '../services/comments.js';
 import { MetaService } from '../services/meta.js';
 import asyncHandler from '../utils/async-handler.js';
 const router = express.Router();
@@ -20,7 +17,6 @@ const readHandler = asyncHandler(async (req, res, next) => {
         schema: req.schema,
     });
     let result;
-    let isComment;
     if (req.singleton) {
         result = await service.readSingleton(req.sanitizedQuery);
     }
@@ -28,24 +24,9 @@ const readHandler = asyncHandler(async (req, res, next) => {
         result = await service.readMany(req.body.keys, req.sanitizedQuery);
     }
     else {
-        const sanitizedFilter = req.sanitizedQuery.filter;
-        if (sanitizedFilter &&
-            '_and' in sanitizedFilter &&
-            Array.isArray(sanitizedFilter['_and']) &&
-            sanitizedFilter['_and'].find((andItem) => 'action' in andItem && '_eq' in andItem['action'] && andItem['action']['_eq'] === 'comment')) {
-            const commentsService = new CommentsService({
-                accountability: req.accountability,
-                schema: req.schema,
-                serviceOrigin: 'activity',
-            });
-            result = await commentsService.readByQuery(req.sanitizedQuery);
-            isComment = true;
-        }
-        else {
-            result = await service.readByQuery(req.sanitizedQuery);
-        }
+        result = await service.readByQuery(req.sanitizedQuery);
     }
-    const meta = await metaService.getMetaForQuery(isComment ? 'directus_comments' : 'directus_activity', req.sanitizedQuery);
+    const meta = await metaService.getMetaForQuery('directus_activity', req.sanitizedQuery);
     res.locals['payload'] = {
         data: result,
         meta,
@@ -65,71 +46,4 @@ router.get('/:pk', asyncHandler(async (req, res, next) => {
     };
     return next();
 }), respond);
-const createCommentSchema = Joi.object({
-    comment: Joi.string().required(),
-    collection: Joi.string().required(),
-    item: [Joi.number().required(), Joi.string().required()],
-});
-router.post('/comment', asyncHandler(async (req, res, next) => {
-    const service = new CommentsService({
-        accountability: req.accountability,
-        schema: req.schema,
-        serviceOrigin: 'activity',
-    });
-    const { error } = createCommentSchema.validate(req.body);
-    if (error) {
-        throw new InvalidPayloadError({ reason: error.message });
-    }
-    const primaryKey = await service.createOne(req.body);
-    try {
-        const record = await service.readOne(primaryKey, req.sanitizedQuery);
-        res.locals['payload'] = {
-            data: record || null,
-        };
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
-}), respond);
-const updateCommentSchema = Joi.object({
-    comment: Joi.string().required(),
-});
-router.patch('/comment/:pk', asyncHandler(async (req, res, next) => {
-    const commentsService = new CommentsService({
-        accountability: req.accountability,
-        schema: req.schema,
-        serviceOrigin: 'activity',
-    });
-    const { error } = updateCommentSchema.validate(req.body);
-    if (error) {
-        throw new InvalidPayloadError({ reason: error.message });
-    }
-    const primaryKey = await commentsService.updateOne(req.params['pk'], req.body);
-    try {
-        const record = await commentsService.readOne(primaryKey, req.sanitizedQuery);
-        res.locals['payload'] = {
-            data: record || null,
-        };
-    }
-    catch (error) {
-        if (isDirectusError(error, ErrorCode.Forbidden)) {
-            return next();
-        }
-        throw error;
-    }
-    return next();
-}), respond);
-router.delete('/comment/:pk', asyncHandler(async (req, _res, next) => {
-    const commentsService = new CommentsService({
-        accountability: req.accountability,
-        schema: req.schema,
-        serviceOrigin: 'activity',
-    });
-    await commentsService.deleteOne(req.params['pk']);
-    return next();
-}), respond);
 export default router;

package/dist/controllers/comments.js

@@ -13,7 +13,6 @@ router.post('/', asyncHandler(async (req, res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     const savedKeys = [];
     if (Array.isArray(req.body)) {
@@ -46,7 +45,6 @@ const readHandler = asyncHandler(async (req, res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     const metaService = new MetaService({
         accountability: req.accountability,
@@ -69,7 +67,6 @@ router.get('/:pk', asyncHandler(async (req, res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     const record = await service.readOne(req.params['pk'], req.sanitizedQuery);
     res.locals['payload'] = { data: record || null };
@@ -79,7 +76,6 @@ router.patch('/', validateBatch('update'), asyncHandler(async (req, res, next) =
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     let keys = [];
     if (Array.isArray(req.body)) {
@@ -108,7 +104,6 @@ router.patch('/:pk', asyncHandler(async (req, res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     const primaryKey = await service.updateOne(req.params['pk'], req.body);
     try {
@@ -127,7 +122,6 @@ router.delete('/', validateBatch('delete'), asyncHandler(async (req, _res, next)
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     if (Array.isArray(req.body)) {
         await service.deleteMany(req.body);
@@ -145,7 +139,6 @@ router.delete('/:pk', asyncHandler(async (req, _res, next) => {
     const service = new CommentsService({
         accountability: req.accountability,
         schema: req.schema,
-        serviceOrigin: 'comments',
     });
     await service.deleteOne(req.params['pk']);
     return next();

package/dist/controllers/tus.d.ts

@@ -1,3 +1,2 @@
-export declare function scheduleTusCleanup(): void;
 declare const router: import("express-serve-static-core").Router;
 export default router;

package/dist/controllers/tus.js

@@ -1,11 +1,8 @@
 import { Router } from 'express';
-import { RESUMABLE_UPLOADS } from '../constants.js';
 import getDatabase from '../database/index.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 import { createTusServer } from '../services/tus/index.js';
 import asyncHandler from '../utils/async-handler.js';
-import { getSchema } from '../utils/get-schema.js';
-import { scheduleSynchronizedJob, validateCron } from '../utils/schedule.js';
 const mapAction = (method) => {
     switch (method) {
         case 'POST':
@@ -40,19 +37,6 @@ const handler = asyncHandler(async (req, res) => {
     await tusServer.handle(req, res);
     cleanupServer();
 });
-export function scheduleTusCleanup() {
-    if (!RESUMABLE_UPLOADS.ENABLED)
-        return;
-    if (validateCron(RESUMABLE_UPLOADS.SCHEDULE)) {
-        scheduleSynchronizedJob('tus-cleanup', RESUMABLE_UPLOADS.SCHEDULE, async () => {
-            const [tusServer, cleanupServer] = await createTusServer({
-                schema: await getSchema(),
-            });
-            await tusServer.cleanUpExpiredUploads();
-            cleanupServer();
-        });
-    }
-}
 const router = Router();
 router.post('/', checkFileAccess, handler);
 router.patch('/:id', checkFileAccess, handler);

package/dist/controllers/versions.js

@@ -154,14 +154,7 @@ router.get('/:pk/compare', asyncHandler(async (req, res, next) => {
     });
     const version = await service.readOne(req.params['pk']);
     const { outdated, mainHash } = await service.verifyHash(version['collection'], version['item'], version['hash']);
-    let current;
-    if (version['delta']) {
-        current = version['delta'];
-    }
-    else {
-        const saves = await service.getVersionSavesById(version['id']);
-        current = assign({}, ...saves);
-    }
+    const current = assign({}, version['delta']);
     const main = await service.getMainItem(version['collection'], version['item']);
     res.locals['payload'] = { data: { outdated, mainHash, current, main } };
     return next();

package/dist/database/migrations/20240909A-separate-comments.js

@@ -2,12 +2,7 @@ import { Action } from '@directus/constants';
 export async function up(knex) {
     await knex.schema.createTable('directus_comments', (table) => {
         table.uuid('id').primary().notNullable();
-        table
-            .string('collection', 64)
-            .notNullable()
-            .references('collection')
-            .inTable('directus_collections')
-            .onDelete('CASCADE');
+        table.string('collection', 64).notNullable();
         table.string('item').notNullable();
         table.text('comment').notNullable();
         table.timestamp('date_created').defaultTo(knex.fn.now());

package/dist/database/migrations/20240924A-migrate-legacy-comments.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20240924A-migrate-legacy-comments.js

@@ -0,0 +1,59 @@
+import { Action } from '@directus/constants';
+import { randomUUID } from 'node:crypto';
+export async function up(knex) {
+    // remove foreign key constraint for projects already migrated to retentions-p1
+    try {
+        await knex.schema.alterTable('directus_comments', (table) => {
+            table.dropForeign('collection');
+        });
+    }
+    catch {
+        // ignore
+    }
+    const rowsLimit = 50;
+    let hasMore = true;
+    while (hasMore) {
+        const legacyComments = await knex
+            .select('*')
+            .from('directus_activity')
+            .where('action', '=', Action.COMMENT)
+            .limit(rowsLimit);
+        if (legacyComments.length === 0) {
+            hasMore = false;
+            break;
+        }
+        await knex.transaction(async (trx) => {
+            for (const legacyComment of legacyComments) {
+                let primaryKey;
+                // Migrate 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', '=', legacyComment.id);
+                }
+            }
+        });
+    }
+    await knex.schema.alterTable('directus_activity', (table) => {
+        table.dropColumn('comment');
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_activity', (table) => {
+        table.text('comment');
+    });
+}

package/dist/database/migrations/20240924B-populate-versioning-deltas.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(): Promise<void>;

package/dist/database/migrations/20240924B-populate-versioning-deltas.js

@@ -0,0 +1,32 @@
+import { parseJSON } from '@directus/utils';
+import { assign } from 'lodash-es';
+export async function up(knex) {
+    const rowsLimit = 50;
+    let hasMore = true;
+    while (hasMore) {
+        const missingDeltaVersions = await knex.select('id').from('directus_versions').whereNull('delta').limit(rowsLimit);
+        if (missingDeltaVersions.length === 0) {
+            hasMore = false;
+            break;
+        }
+        await knex.transaction(async (trx) => {
+            for (const missingDeltaVersion of missingDeltaVersions) {
+                const revisions = await trx
+                    .select('delta')
+                    .from('directus_revisions')
+                    .where('version', '=', missingDeltaVersion.id)
+                    .orderBy('id');
+                const deltas = revisions.map((revision) => typeof revision.delta === 'string' ? parseJSON(revision.delta) : revision.delta ?? {});
+                const consolidatedDelta = assign({}, ...deltas);
+                await trx('directus_versions')
+                    .update({
+                    delta: JSON.stringify(consolidatedDelta),
+                })
+                    .where('id', '=', missingDeltaVersion.id);
+            }
+        });
+    }
+}
+export async function down() {
+    // No down migration required
+}

package/dist/database/run-ast/utils/apply-parent-filters.js

@@ -33,6 +33,10 @@ export function applyParentFilters(schema, nestedCollectionNodes, parentItem) {
             const foreignField = nestedNode.relation.field;
             const foreignIds = uniq(parentItems.map((res) => res[nestedNode.parentKey])).filter((id) => !isNil(id));
             merge(nestedNode, { query: { filter: { [foreignField]: { _in: foreignIds } } } });
+            if (nestedNode.relation.meta?.junction_field) {
+                const junctionField = nestedNode.relation.meta.junction_field;
+                merge(nestedNode, { query: { filter: { [junctionField]: { _nnull: true } } } });
+            }
         }
         else if (nestedNode.type === 'a2o') {
             const keysPerCollection = {};

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 {};