@directus/api 13.1.1 → 14.0.0

package/dist/services/users.js

@@ -6,8 +6,8 @@ import { cloneDeep, isEmpty } from 'lodash-es';
 import { performance } from 'perf_hooks';
 import getDatabase from '../database/index.js';
 import env from '../env.js';
-import { ForbiddenError } from '../errors/forbidden.js';
-import { InvalidPayloadError, RecordNotUniqueError, UnprocessableContentError } from '../errors/index.js';
+import { ForbiddenError } from '@directus/errors';
+import { InvalidPayloadError, RecordNotUniqueError, UnprocessableContentError } from '@directus/errors';
 import isUrlAllowed from '../utils/is-url-allowed.js';
 import { verifyJWT } from '../utils/jwt.js';
 import { stall } from '../utils/stall.js';
@@ -274,7 +274,9 @@ export class UsersService extends ItemsService {
         catch (err) {
             (opts || (opts = {})).preMutationError = err;
         }
+        // Manual constraint, see https://github.com/directus/directus/pull/19912
         await this.knex('directus_notifications').update({ sender: null }).whereIn('sender', keys);
+        await this.knex('directus_versions').update({ user_updated: null }).whereIn('user_updated', keys);
         await super.deleteMany(keys, opts);
         return keys;
     }

package/dist/services/utils.d.ts

@@ -10,4 +10,5 @@ export declare class UtilsService {
         item: PrimaryKey;
         to: PrimaryKey;
     }): Promise<void>;
+    clearCache(): Promise<void>;
 }

package/dist/services/utils.js

@@ -1,8 +1,8 @@
+import { flushCaches, getCache } from '../cache.js';
 import getDatabase from '../database/index.js';
 import { systemCollectionRows } from '../database/system-data/collections/index.js';
 import emitter from '../emitter.js';
-import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
-import { getCache } from '../cache.js';
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
 export class UtilsService {
     knex;
@@ -112,4 +112,10 @@ export class UtilsService {
             accountability: this.accountability,
         });
     }
+    async clearCache() {
+        if (this.accountability?.admin !== true) {
+            throw new ForbiddenError();
+        }
+        return flushCaches(true);
+    }
 }

package/dist/services/versions.d.ts

@@ -0,0 +1,21 @@
+import type { Item, PrimaryKey, Query } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
+export declare class VersionsService extends ItemsService {
+    authorizationService: AuthorizationService;
+    constructor(options: AbstractServiceOptions);
+    private validateCreateData;
+    getMainItem(collection: string, item: PrimaryKey, query?: Query): Promise<Item>;
+    verifyHash(collection: string, item: PrimaryKey, hash: string): Promise<{
+        outdated: boolean;
+        mainHash: string;
+    }>;
+    getVersionSavesById(id: PrimaryKey): Promise<Partial<Item>[]>;
+    getVersionSaves(key: string, collection: string, item: string | undefined): Promise<Partial<Item>[] | null>;
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    save(key: PrimaryKey, data: Partial<Item>): Promise<Partial<Item>>;
+    promote(version: PrimaryKey, mainHash: string, fields?: string[]): Promise<import("../types/items.js").PrimaryKey>;
+}

package/dist/services/versions.js

@@ -0,0 +1,232 @@
+import { Action } from '@directus/constants';
+import { InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
+import Joi from 'joi';
+import { assign, pick } from 'lodash-es';
+import objectHash from 'object-hash';
+import getDatabase from '../database/index.js';
+import emitter from '../emitter.js';
+import { ActivityService } from './activity.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
+import { PayloadService } from './payload.js';
+import { RevisionsService } from './revisions.js';
+export class VersionsService extends ItemsService {
+    authorizationService;
+    constructor(options) {
+        super('directus_versions', options);
+        this.authorizationService = new AuthorizationService({
+            accountability: this.accountability,
+            knex: this.knex,
+            schema: this.schema,
+        });
+    }
+    async validateCreateData(data) {
+        if (!data['key'])
+            throw new InvalidPayloadError({ reason: `"key" is required` });
+        // Reserves the "main" version key for the version query parameter
+        if (data['key'] === 'main')
+            throw new InvalidPayloadError({ reason: `"main" is a reserved version key` });
+        if (!data['collection']) {
+            throw new InvalidPayloadError({ reason: `"collection" is required` });
+        }
+        if (!data['item'])
+            throw new InvalidPayloadError({ reason: `"item" is required` });
+        const { CollectionsService } = await import('./collections.js');
+        const collectionsService = new CollectionsService({
+            accountability: null,
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const existingCollection = await collectionsService.readOne(data['collection']);
+        if (!existingCollection.meta?.versioning) {
+            throw new UnprocessableContentError({
+                reason: `Content Versioning is not enabled for collection "${data['collection']}"`,
+            });
+        }
+        const existingVersions = await super.readByQuery({
+            aggregate: { count: ['*'] },
+            filter: { key: { _eq: data['key'] }, collection: { _eq: data['collection'] }, item: { _eq: data['item'] } },
+        });
+        if (existingVersions[0]['count'] > 0) {
+            throw new UnprocessableContentError({
+                reason: `Version "${data['key']}" already exists for item "${data['item']}" in collection "${data['collection']}"`,
+            });
+        }
+        // will throw an error if the accountability does not have permission to read the item
+        await this.authorizationService.checkAccess('read', data['collection'], data['item']);
+    }
+    async getMainItem(collection, item, query) {
+        // will throw an error if the accountability does not have permission to read the item
+        await this.authorizationService.checkAccess('read', collection, item);
+        const itemsService = new ItemsService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        return await itemsService.readOne(item, query);
+    }
+    async verifyHash(collection, item, hash) {
+        const mainItem = await this.getMainItem(collection, item);
+        const mainHash = objectHash(mainItem);
+        return { outdated: hash !== mainHash, mainHash };
+    }
+    async getVersionSavesById(id) {
+        const revisionsService = new RevisionsService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const result = await revisionsService.readByQuery({
+            filter: { version: { _eq: id } },
+        });
+        return result.map((revision) => revision['delta']);
+    }
+    async getVersionSaves(key, collection, item) {
+        const filter = {
+            key: { _eq: key },
+            collection: { _eq: collection },
+        };
+        if (item) {
+            filter['item'] = { _eq: item };
+        }
+        const versions = await this.readByQuery({ filter });
+        if (!versions?.[0])
+            return null;
+        const saves = await this.getVersionSavesById(versions[0]['id']);
+        return saves;
+    }
+    async createOne(data, opts) {
+        await this.validateCreateData(data);
+        const mainItem = await this.getMainItem(data['collection'], data['item']);
+        data['hash'] = objectHash(mainItem);
+        return super.createOne(data, opts);
+    }
+    async createMany(data, opts) {
+        if (!Array.isArray(data)) {
+            throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
+        }
+        const keyCombos = new Set();
+        for (const item of data) {
+            await this.validateCreateData(item);
+            const keyCombo = `${item['key']}-${item['collection']}-${item['item']}`;
+            if (keyCombos.has(keyCombo)) {
+                throw new UnprocessableContentError({
+                    reason: `Cannot create multiple versions on "${item['item']}" in collection "${item['collection']}" with the same key "${item['key']}"`,
+                });
+            }
+            keyCombos.add(keyCombo);
+            const mainItem = await this.getMainItem(item['collection'], item['item']);
+            item['hash'] = objectHash(mainItem);
+        }
+        return super.createMany(data, opts);
+    }
+    async updateMany(keys, data, opts) {
+        // Only allow updates on "key" and "name" fields
+        const versionUpdateSchema = Joi.object({
+            key: Joi.string(),
+            name: Joi.string().allow(null).optional(),
+        });
+        const { error } = versionUpdateSchema.validate(data);
+        if (error)
+            throw new InvalidPayloadError({ reason: error.message });
+        if ('key' in data) {
+            // Reserves the "main" version key for the version query parameter
+            if (data['key'] === 'main')
+                throw new InvalidPayloadError({ reason: `"main" is a reserved version key` });
+            const keyCombos = new Set();
+            for (const pk of keys) {
+                const { collection, item } = await this.readOne(pk, { fields: ['collection', 'item'] });
+                const keyCombo = `${data['key']}-${collection}-${item}`;
+                if (keyCombos.has(keyCombo)) {
+                    throw new UnprocessableContentError({
+                        reason: `Cannot update multiple versions on "${item}" in collection "${collection}" to the same key "${data['key']}"`,
+                    });
+                }
+                keyCombos.add(keyCombo);
+                const existingVersions = await super.readByQuery({
+                    aggregate: { count: ['*'] },
+                    filter: { id: { _neq: pk }, key: { _eq: data['key'] }, collection: { _eq: collection }, item: { _eq: item } },
+                });
+                if (existingVersions[0]['count'] > 0) {
+                    throw new UnprocessableContentError({
+                        reason: `Version "${data['key']}" already exists for item "${item}" in collection "${collection}"`,
+                    });
+                }
+            }
+        }
+        return super.updateMany(keys, data, opts);
+    }
+    async save(key, data) {
+        const version = await super.readOne(key);
+        const payloadService = new PayloadService(this.collection, {
+            accountability: this.accountability,
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const activityService = new ActivityService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const revisionsService = new RevisionsService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const activity = await activityService.createOne({
+            action: Action.VERSION_SAVE,
+            user: this.accountability?.user ?? null,
+            collection: version['collection'],
+            ip: this.accountability?.ip ?? null,
+            user_agent: this.accountability?.userAgent ?? null,
+            origin: this.accountability?.origin ?? null,
+            item: version['item'],
+        });
+        const revisionDelta = await payloadService.prepareDelta(data);
+        await revisionsService.createOne({
+            activity,
+            version: key,
+            collection: version['collection'],
+            item: version['item'],
+            data: revisionDelta,
+            delta: revisionDelta,
+        });
+        return data;
+    }
+    async promote(version, mainHash, fields) {
+        const { id, collection, item } = (await this.readOne(version));
+        // will throw an error if the accountability does not have permission to update the item
+        await this.authorizationService.checkAccess('update', collection, item);
+        const { outdated } = await this.verifyHash(collection, item, mainHash);
+        if (outdated) {
+            throw new UnprocessableContentError({
+                reason: `Main item has changed since this version was last updated`,
+            });
+        }
+        const saves = await this.getVersionSavesById(id);
+        const versionResult = assign({}, ...saves);
+        const payloadToUpdate = fields ? pick(versionResult, fields) : versionResult;
+        const itemsService = new ItemsService(collection, {
+            accountability: this.accountability,
+            schema: this.schema,
+        });
+        const payloadAfterHooks = await emitter.emitFilter(['items.promote', `${collection}.items.promote`], payloadToUpdate, {
+            collection,
+            item,
+            version,
+        }, {
+            database: getDatabase(),
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        const updatedItemKey = await itemsService.updateOne(item, payloadAfterHooks);
+        emitter.emitAction(['items.promote', `${collection}.items.promote`], {
+            payload: payloadAfterHooks,
+            collection,
+            item: updatedItemKey,
+            version,
+        }, {
+            database: getDatabase(),
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        return updatedItemKey;
+    }
+}

package/dist/services/websocket.js

@@ -1,9 +1,19 @@
 import { getWebSocketController } from '../websocket/controllers/index.js';
+import { ServiceUnavailableError } from '@directus/errors';
+import { toBoolean } from '../utils/to-boolean.js';
 import emitter from '../emitter.js';
+import env from '../env.js';
 export class WebSocketService {
     controller;
     constructor() {
-        this.controller = getWebSocketController();
+        if (!toBoolean(env['WEBSOCKETS_ENABLED']) || !toBoolean(env['WEBSOCKETS_REST_ENABLED'])) {
+            throw new ServiceUnavailableError({ service: 'ws', reason: 'WebSocket server is disabled' });
+        }
+        const controller = getWebSocketController();
+        if (!controller) {
+            throw new ServiceUnavailableError({ service: 'ws', reason: 'WebSocket server is not initialized' });
+        }
+        this.controller = controller;
     }
     on(event, callback) {
         emitter.onAction('websocket.' + event, callback);

package/dist/types/collection.d.ts

@@ -7,6 +7,7 @@ export type CollectionMeta = {
     singleton: boolean;
     icon: string | null;
     translations: Record<string, string>;
+    versioning: boolean;
     item_duplication_fields: string[] | null;
     accountability: 'all' | 'accountability' | null;
     group: string | null;

package/dist/types/index.d.ts

@@ -4,7 +4,6 @@ export * from './auth.js';
 export * from './collection.js';
 export * from './database.js';
 export * from './events.js';
-export * from './files.js';
 export * from './graphql.js';
 export * from './items.js';
 export * from './meta.js';

package/dist/types/index.js

@@ -4,7 +4,6 @@ export * from './auth.js';
 export * from './collection.js';
 export * from './database.js';
 export * from './events.js';
-export * from './files.js';
 export * from './graphql.js';
 export * from './items.js';
 export * from './meta.js';

package/dist/utils/apply-query.d.ts

@@ -18,7 +18,7 @@ export type ColumnSortRecord = {
     order: 'asc' | 'desc';
     column: string;
 };
-export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootSort: string[], collection: string, aliasMap: AliasMap, returnRecords?: boolean): {
+export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, query: Query, collection: string, aliasMap: AliasMap, returnRecords?: boolean): {
     sortRecords: {
         order: "asc" | "desc";
         column: any;

package/dist/utils/apply-query.js

@@ -3,7 +3,7 @@ import { clone, isPlainObject } from 'lodash-es';
 import { customAlphabet } from 'nanoid/non-secure';
 import validate from 'uuid-validate';
 import { getHelpers } from '../database/helpers/index.js';
-import { InvalidQueryError } from '../errors/index.js';
+import { InvalidQueryError } from '@directus/errors';
 import { getColumnPath } from './get-column-path.js';
 import { getColumn } from './get-column.js';
 import { getRelationInfo } from './get-relation-info.js';
@@ -24,7 +24,7 @@ export default function applyQuery(knex, collection, dbQuery, query, schema, opt
         applyOffset(knex, dbQuery, query.limit * (query.page - 1));
     }
     if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
-        const sortResult = applySort(knex, schema, dbQuery, query.sort, collection, aliasMap);
+        const sortResult = applySort(knex, schema, dbQuery, query, collection, aliasMap);
         if (!hasJoins) {
             hasJoins = sortResult.hasJoins;
         }
@@ -128,7 +128,9 @@ function addJoin({ path, collection, aliasMap, rootQuery, schema, relations, kne
         }
     }
 }
-export function applySort(knex, schema, rootQuery, rootSort, collection, aliasMap, returnRecords = false) {
+export function applySort(knex, schema, rootQuery, query, collection, aliasMap, returnRecords = false) {
+    const rootSort = query.sort;
+    const aggregate = query?.aggregate;
     const relations = schema.relations;
     let hasJoins = false;
     let hasMultiRelationalSort = false;
@@ -141,6 +143,32 @@ export function applySort(knex, schema, rootQuery, rootSort, collection, aliasMa
         if (column[0].startsWith('-')) {
             column[0] = column[0].substring(1);
         }
+        // Is the column name one of the aggregate functions used in the query if there is any?
+        if (Object.keys(aggregate ?? {}).includes(column[0])) {
+            // If so, return the column name without the order prefix
+            const operation = column[0];
+            // Get the field for the aggregate function
+            const field = column[1];
+            // If the operation is countAll there is no field.
+            if (operation === 'countAll') {
+                return {
+                    order,
+                    column: 'countAll',
+                };
+            }
+            // If the operation is a root count there is no field.
+            if (operation === 'count' && (field === '*' || !field)) {
+                return {
+                    order,
+                    column: 'count',
+                };
+            }
+            // Return the column name with the operation and field name
+            return {
+                order,
+                column: returnRecords ? column[0] : `${operation}->${field}`,
+            };
+        }
         if (column.length === 1) {
             const pathRoot = column[0].split(':')[0];
             const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);

package/dist/utils/delete-from-require-cache.d.ts

@@ -0,0 +1 @@
+export declare function deleteFromRequireCache(modulePath: string): void;

package/dist/utils/delete-from-require-cache.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export function deleteFromRequireCache(modulePath) {
+    delete require.cache[require.resolve(modulePath)];
+}

package/dist/utils/get-accountability-for-token.js

@@ -1,6 +1,6 @@
 import getDatabase from '../database/index.js';
 import env from '../env.js';
-import { InvalidCredentialsError } from '../errors/index.js';
+import { InvalidCredentialsError } from '@directus/errors';
 import isDirectusJWT from './is-directus-jwt.js';
 import { verifyAccessJWT } from './jwt.js';
 export async function getAccountabilityForToken(token, accountability) {

package/dist/utils/get-ast-from-query.js

@@ -3,7 +3,7 @@
  */
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
 import { cloneDeep, isEmpty, mapKeys, omitBy, uniq } from 'lodash-es';
-import { getRelationType } from '../utils/get-relation-type.js';
+import { getRelationType } from './get-relation-type.js';
 export default async function getASTFromQuery(collection, query, schema, options) {
     query = cloneDeep(query);
     const accountability = options?.accountability;

package/dist/utils/get-column-path.js

@@ -1,4 +1,4 @@
-import { InvalidQueryError } from '../errors/index.js';
+import { InvalidQueryError } from '@directus/errors';
 import { getRelationInfo } from './get-relation-info.js';
 /**
  * Converts a Directus field list path to the correct SQL names based on the constructed alias map.

package/dist/utils/get-column.js

@@ -1,7 +1,7 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
 import { getFunctionsForType } from '@directus/utils';
 import { getFunctions } from '../database/helpers/index.js';
-import { InvalidQueryError } from '../errors/index.js';
+import { InvalidQueryError } from '@directus/errors';
 import { applyFunctionToColumnName } from './apply-function-to-column-name.js';
 /**
  * Return column prefixed by table. If column includes functions (like `year(date_created)`), the

package/dist/utils/get-default-value.d.ts

@@ -1,5 +1,4 @@
-import type { SchemaOverview } from '@directus/schema/types/overview';
-import type { Column } from '@directus/schema';
+import type { Column, SchemaOverview } from '@directus/schema';
 import type { FieldMeta } from '@directus/types';
 export default function getDefaultValue(column: SchemaOverview[string]['columns'][string] | Column, field?: {
     special?: FieldMeta['special'];

package/dist/utils/get-permissions.js

@@ -8,7 +8,7 @@ import env from '../env.js';
 import logger from '../logger.js';
 import { RolesService } from '../services/roles.js';
 import { UsersService } from '../services/users.js';
-import { mergePermissions } from '../utils/merge-permissions.js';
+import { mergePermissions } from './merge-permissions.js';
 import { mergePermissionsForShare } from './merge-permissions-for-share.js';
 export async function getPermissions(accountability, schema) {
     const database = getDatabase();

package/dist/utils/get-service.js

@@ -1,4 +1,4 @@
-import { ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, UsersService, WebhooksService, } from '../services/index.js';
+import { ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, UsersService, VersionsService, WebhooksService, } from '../services/index.js';
 /**
  * Select the correct service for the given collection. This allows the individual services to run
  * their custom checks (f.e. it allows UsersService to prevent updating TFA secret from outside)
@@ -43,6 +43,8 @@ export function getService(collection, opts) {
             return new UsersService(opts);
         case 'directus_webhooks':
             return new WebhooksService(opts);
+        case 'directus_versions':
+            return new VersionsService(opts);
         default:
             return new ItemsService(collection, opts);
     }

package/dist/utils/import-file-url.d.ts

@@ -0,0 +1,5 @@
+interface ImportOptions {
+    fresh?: boolean;
+}
+export declare function importFileUrl(url: string, root: string, options?: ImportOptions): Promise<any>;
+export {};

package/dist/utils/import-file-url.js

@@ -0,0 +1,6 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { pathToRelativeUrl } from '@directus/utils/node';
+export function importFileUrl(url, root, options = {}) {
+    return import(`./${pathToRelativeUrl(url, dirname(fileURLToPath(root)))}${options.fresh ? `?t=${Date.now()}` : ''}`);
+}

package/dist/utils/job-queue.d.ts

@@ -1,9 +1,8 @@
-type Job = () => Promise<void> | void;
+import type { PromiseCallback } from '@directus/types';
 export declare class JobQueue {
     private running;
     private jobs;
     constructor();
-    enqueue(job: Job): void;
+    enqueue(job: PromiseCallback): void;
     private run;
 }
-export {};

package/dist/utils/jwt.js

@@ -1,5 +1,5 @@
 import jwt from 'jsonwebtoken';
-import { InvalidTokenError, ServiceUnavailableError, TokenExpiredError } from '../errors/index.js';
+import { InvalidTokenError, ServiceUnavailableError, TokenExpiredError } from '@directus/errors';
 export function verifyJWT(token, secret) {
     let payload;
     try {

package/dist/utils/redact-object.js

@@ -12,7 +12,6 @@ import { isObject } from '@directus/utils';
 export function redactObject(input, redact, replacement) {
     const wildcardChars = ['*', '**'];
     const clone = JSON.parse(JSON.stringify(input, getReplacer(replacement, redact.values)));
-    const visited = new WeakSet();
     if (redact.keys) {
         traverse(clone, redact.keys);
     }
@@ -21,7 +20,6 @@ export function redactObject(input, redact, replacement) {
         if (checkKeyPaths.length === 0) {
             return;
         }
-        visited.add(object);
         const REDACTED_TEXT = replacement();
         const globalCheckPaths = [];
         for (const key of Object.keys(object)) {
@@ -73,7 +71,7 @@ export function redactObject(input, redact, replacement) {
                 }
             }
             const value = object[key];
-            if (isObject(value) && !visited.has(value)) {
+            if (isObject(value)) {
                 traverse(value, [...globalCheckPaths, ...localCheckPaths]);
             }
         }
@@ -86,7 +84,15 @@ export function getReplacer(replacement, values) {
     const filteredValues = values
         ? Object.entries(values).filter(([_k, v]) => typeof v === 'string' && v.length > 0)
         : [];
+    const seen = new WeakSet();
     return (_key, value) => {
+        // Skip circular values
+        if (isObject(value)) {
+            if (seen.has(value)) {
+                return;
+            }
+            seen.add(value);
+        }
         if (value instanceof Error) {
             return {
                 name: value.name,

package/dist/utils/sanitize-query.js

@@ -46,6 +46,9 @@ export function sanitizeQuery(rawQuery, accountability) {
     if (rawQuery['search'] && typeof rawQuery['search'] === 'string') {
         query.search = rawQuery['search'];
     }
+    if (rawQuery['version']) {
+        query.version = rawQuery['version'];
+    }
     if (rawQuery['export']) {
         query.export = rawQuery['export'];
     }

package/dist/utils/transformations.d.ts

@@ -1,4 +1,5 @@
-import type { File, Transformation, TransformationSet } from '../types/index.js';
+import type { File } from '@directus/types';
+import type { Transformation, TransformationSet } from '../types/index.js';
 export declare function resolvePreset({ transformationParams, acceptFormat }: TransformationSet, file: File): Transformation[];
 /**
  * Try to extract a file format from an array of `Transformation`'s.

package/dist/utils/validate-diff.js

@@ -1,5 +1,5 @@
 import Joi from 'joi';
-import { InvalidPayloadError } from '../errors/index.js';
+import { InvalidPayloadError } from '@directus/errors';
 import { DiffKind } from '../types/snapshot.js';
 const deepDiffSchema = Joi.object({
     kind: Joi.string()

package/dist/utils/validate-keys.js

@@ -1,4 +1,4 @@
-import { ForbiddenError } from '../errors/index.js';
+import { ForbiddenError } from '@directus/errors';
 import validateUUID from 'uuid-validate';
 /**
  * Validate keys based on its type

package/dist/utils/validate-query.js

@@ -2,7 +2,7 @@ import Joi from 'joi';
 import { isPlainObject, uniq } from 'lodash-es';
 import { stringify } from 'wellknown';
 import env from '../env.js';
-import { InvalidQueryError } from '../errors/index.js';
+import { InvalidQueryError } from '@directus/errors';
 import { calculateFieldDepth } from './calculate-field-depth.js';
 const querySchema = Joi.object({
     fields: Joi.array().items(Joi.string()),
@@ -17,6 +17,7 @@ const querySchema = Joi.object({
     meta: Joi.array().items(Joi.string().valid('total_count', 'filter_count')),
     search: Joi.string(),
     export: Joi.string().valid('csv', 'json', 'xml', 'yaml'),
+    version: Joi.string(),
     aggregate: Joi.object(),
     deep: Joi.object(),
     alias: Joi.object(),

package/dist/utils/validate-snapshot.js

@@ -2,7 +2,7 @@ import { TYPES } from '@directus/constants';
 import Joi from 'joi';
 import { ALIAS_TYPES } from '../constants.js';
 import { getDatabaseClient } from '../database/index.js';
-import { InvalidPayloadError } from '../errors/index.js';
+import { InvalidPayloadError } from '@directus/errors';
 import { DatabaseClients } from '../types/index.js';
 import { version as currentDirectusVersion } from './package.js';
 const snapshotJoiSchema = Joi.object({