@directus/api 18.2.1 → 19.0.1

package/dist/database/migrations/20240311A-deprecate-webhooks.js

@@ -0,0 +1,125 @@
+import { parseJSON, toArray } from '@directus/utils';
+import { randomUUID } from 'node:crypto';
+// To avoid typos
+const TABLE_WEBHOOKS = 'directus_webhooks';
+const TABLE_FLOWS = 'directus_flows';
+const TABLE_OPERATIONS = 'directus_operations';
+const NEW_COLUMN_WAS_ACTIVE = 'was_active_before_deprecation';
+const NEW_COLUMN_FLOW = 'migrated_flow';
+/**
+ * 0. Identify and persist which webhooks were active before deprecation
+ * 1. Migrate existing webhooks over to identically behaving Flows
+ * 2. Disable existing webhooks
+ * 3. Dont drop webhooks yet
+ */
+export async function up(knex) {
+    // 0. Identify and persist which webhooks were active before deprecation
+    await knex.schema.alterTable(TABLE_WEBHOOKS, (table) => {
+        table.boolean(NEW_COLUMN_WAS_ACTIVE).notNullable().defaultTo(false);
+        table.uuid(NEW_COLUMN_FLOW).nullable();
+        table.foreign(NEW_COLUMN_FLOW).references(`${TABLE_FLOWS}.id`).onDelete('SET NULL');
+    });
+    await knex(TABLE_WEBHOOKS)
+        .update({ [NEW_COLUMN_WAS_ACTIVE]: true })
+        .where({ status: 'active' });
+    const webhooks = await knex.select('*').from(TABLE_WEBHOOKS);
+    // 1. Migrate existing webhooks over to identically behaving Flows
+    await knex.transaction(async (trx) => {
+        for (const webhook of webhooks) {
+            const flowId = randomUUID();
+            const operationIdRunScript = randomUUID();
+            const operationIdWebhook = randomUUID();
+            const newFlow = {
+                id: flowId,
+                name: webhook.name,
+                icon: 'webhook',
+                // color: null,
+                description: 'Auto-generated by Directus Migration\n\nWebhooks were deprecated and have been moved into Flows for you automatically.',
+                status: webhook.status, // Only activate already active webhooks!
+                trigger: 'event',
+                // accountability: "all",
+                options: {
+                    type: 'action',
+                    scope: toArray(webhook.actions)
+                        .filter((action) => action.trim() !== '')
+                        .map((scope) => `items.${scope}`),
+                    collections: toArray(webhook.collections).filter((collection) => collection.trim() !== ''),
+                },
+                operation: null, // Fill this in later --> `operationIdRunScript`
+                // date_created: Default Date,
+                // user_created: null,
+            };
+            const operationRunScript = {
+                id: operationIdRunScript,
+                name: 'Transforming Payload for Webhook',
+                key: 'payload-transform',
+                type: 'exec',
+                position_x: 19,
+                position_y: 1,
+                options: {
+                    code: '/**\n * Webhook data slightly differs from Flow trigger data.\n * This flow converts the new Flow format into the older Webhook shape\n * in order to not break existing logic of consumers.\n */ \nmodule.exports = async function(data) {\n    const crudOperation = data.$trigger.event.split(".").at(-1);\n    const keyOrKeys = crudOperation === "create" ? "key" : "keys";\n    return {\n        event: `items.${crudOperation}`,\n        accountability: { user: data.$accountability.user, role: data.$accountability.role },\n        payload: data.$trigger.payload,\n        [keyOrKeys]: data.$trigger?.[keyOrKeys],\n        collection: data.$trigger.collection,\n    };\n}',
+                },
+                resolve: operationIdWebhook,
+                reject: null,
+                flow: flowId,
+                // date_created: "",
+                // user_created: "",
+            };
+            const operationWebhook = {
+                id: operationIdWebhook,
+                name: 'Webhook',
+                key: 'webhook',
+                type: 'request',
+                position_x: 37,
+                position_y: 1,
+                options: {
+                    url: webhook.url,
+                    body: webhook.data ? '{{$last}}' : undefined,
+                    method: webhook.method,
+                    headers: typeof webhook.headers === 'string' ? parseJSON(webhook.headers) : webhook.headers,
+                },
+                resolve: null,
+                reject: null,
+                flow: flowId,
+                // date_created: "",
+                // user_created: "",
+            };
+            await trx(TABLE_FLOWS).insert(newFlow);
+            // Only need to transform the payload if the webhook enabled transmitting it
+            if (webhook.data && webhook.method !== 'GET') {
+                // Order is important due to IDs
+                await trx(TABLE_OPERATIONS).insert(operationWebhook);
+                await trx(TABLE_OPERATIONS).insert(operationRunScript);
+                await trx(TABLE_FLOWS).update({ operation: operationIdRunScript }).where({ id: flowId });
+            }
+            else {
+                operationWebhook.position_x = 19; // Reset it because the Run-Script will be missing
+                await trx(TABLE_OPERATIONS).insert(operationWebhook);
+                await trx(TABLE_FLOWS).update({ operation: operationIdWebhook }).where({ id: flowId });
+            }
+            // Persist new Flow/s so that we can retroactively remove them on potential down-migrations
+            await trx(TABLE_WEBHOOKS)
+                .update({ [NEW_COLUMN_FLOW]: flowId })
+                .where({ id: webhook.id });
+            // 2. Disable existing webhooks
+            await trx(TABLE_WEBHOOKS).update({ status: 'inactive' });
+        }
+    });
+}
+/**
+ * Dont completely drop Webhooks yet.
+ * Lets preserve the data and drop them in the next release to be extra safe with users data.
+ */
+export async function down(knex) {
+    // Remove Flows created by the up-migration
+    const migratedFlowIds = (await knex(TABLE_WEBHOOKS).select(NEW_COLUMN_FLOW).whereNotNull(NEW_COLUMN_FLOW)).map((col) => col[NEW_COLUMN_FLOW]);
+    await knex(TABLE_FLOWS).delete().whereIn('id', migratedFlowIds);
+    // Restore previously activated webhooks
+    await knex(TABLE_WEBHOOKS)
+        .update({ status: 'active' })
+        .where({ [NEW_COLUMN_WAS_ACTIVE]: true });
+    // Cleanup of up-migration
+    await knex.schema.alterTable(TABLE_WEBHOOKS, (table) => {
+        table.dropColumns(NEW_COLUMN_WAS_ACTIVE, NEW_COLUMN_FLOW);
+    });
+}

package/dist/database/run-ast.js

@@ -324,14 +324,15 @@ function mergeWithParentItems(schema, nestedItem, parentItem, nestedNode) {
                     nestedItem[nestedNode.relation.field]?.[schema.collections[nestedNode.relation.related_collection].primary] == parentItem[schema.collections[nestedNode.relation.related_collection].primary]);
             });
             parentItem[nestedNode.fieldKey].push(...itemChildren);
+            const limit = nestedNode.query.limit ?? Number(env['QUERY_LIMIT_DEFAULT']);
             if (nestedNode.query.page && nestedNode.query.page > 1) {
-                parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].slice((nestedNode.query.limit ?? Number(env['QUERY_LIMIT_DEFAULT'])) * (nestedNode.query.page - 1));
+                parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].slice(limit * (nestedNode.query.page - 1));
             }
             if (nestedNode.query.offset && nestedNode.query.offset >= 0) {
                 parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].slice(nestedNode.query.offset);
             }
-            if (nestedNode.query.limit !== -1) {
-                parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].slice(0, nestedNode.query.limit ?? Number(env['QUERY_LIMIT_DEFAULT']));
+            if (limit !== -1) {
+                parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].slice(0, limit);
             }
             parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].sort((a, b) => {
                 // This is pre-filled in get-ast-from-query

package/dist/extensions/manager.d.ts

@@ -81,6 +81,7 @@ export declare class ExtensionManager {
      */
     install(versionId: string): Promise<void>;
     uninstall(folder: string): Promise<void>;
+    broadcastReloadNotification(): Promise<void>;
     /**
      * Load all extensions from disk and register them in their respective places
      */

package/dist/extensions/manager.js

@@ -171,11 +171,14 @@ export class ExtensionManager {
     async install(versionId) {
         await this.installationManager.install(versionId);
         await this.reload({ forceSync: true });
-        await this.messenger.publish(this.reloadChannel, { origin: this.processId });
+        await this.broadcastReloadNotification();
     }
     async uninstall(folder) {
         await this.installationManager.uninstall(folder);
         await this.reload({ forceSync: true });
+        await this.broadcastReloadNotification();
+    }
+    async broadcastReloadNotification() {
         await this.messenger.publish(this.reloadChannel, { origin: this.processId });
     }
     /**

package/dist/middleware/authenticate.js

@@ -15,7 +15,7 @@ export const handler = async (req, _res, next) => {
         app: false,
         ip: getIPFromReq(req),
     };
-    const userAgent = req.get('user-agent');
+    const userAgent = req.get('user-agent')?.substring(0, 1024);
     if (userAgent)
         defaultAccountability.userAgent = userAgent;
     const origin = req.get('origin');

package/dist/services/activity.d.ts

@@ -1,4 +1,5 @@
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { Item, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 import { NotificationsService } from './notifications.js';
 import { UsersService } from './users.js';

package/dist/services/authorization.d.ts

@@ -1,6 +1,6 @@
-import type { Accountability, PermissionsAction, SchemaOverview } from '@directus/types';
+import type { Accountability, Item, PermissionsAction, PrimaryKey, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
-import type { AST, AbstractServiceOptions, Item, PrimaryKey } from '../types/index.js';
+import type { AST, AbstractServiceOptions } from '../types/index.js';
 import { PayloadService } from './payload.js';
 export declare class AuthorizationService {
     knex: Knex;

package/dist/services/collections.d.ts

@@ -1,10 +1,10 @@
 import type { SchemaInspector, Table } from '@directus/schema';
+import { type BaseCollectionMeta } from '@directus/system-data';
 import type { Accountability, RawField, SchemaOverview } from '@directus/types';
 import type Keyv from 'keyv';
 import type { Knex } from 'knex';
 import type { Helpers } from '../database/helpers/index.js';
 import type { AbstractServiceOptions, Collection, MutationOptions } from '../types/index.js';
-import { type BaseCollectionMeta } from '@directus/system-data';
 export type RawCollection = {
     collection: string;
     fields?: RawField[];

package/dist/services/collections.js

@@ -1,6 +1,7 @@
 import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
+import { systemCollectionRows } from '@directus/system-data';
 import { addFieldFlag } from '@directus/utils';
 import { chunk, groupBy, merge, omit } from 'lodash-es';
 import { clearSystemCache, getCache } from '../cache.js';
@@ -10,9 +11,9 @@ import getDatabase, { getSchemaInspector } from '../database/index.js';
 import emitter from '../emitter.js';
 import { getSchema } from '../utils/get-schema.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
+import { transaction } from '../utils/transaction.js';
 import { FieldsService } from './fields.js';
 import { ItemsService } from './items.js';
-import { systemCollectionRows } from '@directus/system-data';
 export class CollectionsService {
     knex;
     helpers;
@@ -56,7 +57,7 @@ export class CollectionsService {
             // Create the collection/fields in a transaction so it'll be reverted in case of errors or
             // permission problems. This might not work reliably in MySQL, as it doesn't support DDL in
             // transactions.
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 if (payload.schema) {
                     // Directus heavily relies on the primary key of a collection, so we have to make sure that
                     // every collection that is created has a primary key. If no primary key field is created
@@ -167,7 +168,7 @@ export class CollectionsService {
     async createMany(payloads, opts) {
         const nestedActionEvents = [];
         try {
-            const collections = await this.knex.transaction(async (trx) => {
+            const collections = await transaction(this.knex, async (trx) => {
                 const service = new CollectionsService({
                     schema: this.schema,
                     accountability: this.accountability,
@@ -361,7 +362,7 @@ export class CollectionsService {
         const collectionKeys = [];
         const nestedActionEvents = [];
         try {
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 const collectionItemsService = new CollectionsService({
                     knex: trx,
                     accountability: this.accountability,
@@ -406,7 +407,7 @@ export class CollectionsService {
         }
         const nestedActionEvents = [];
         try {
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 const service = new CollectionsService({
                     schema: this.schema,
                     accountability: this.accountability,
@@ -453,7 +454,7 @@ export class CollectionsService {
             if (!!collectionToBeDeleted === false) {
                 throw new ForbiddenError();
             }
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 if (collectionToBeDeleted.schema) {
                     await trx.schema.dropTable(collectionKey);
                 }
@@ -552,7 +553,7 @@ export class CollectionsService {
         }
         const nestedActionEvents = [];
         try {
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 const service = new CollectionsService({
                     schema: this.schema,
                     accountability: this.accountability,

package/dist/services/extensions.d.ts

@@ -15,7 +15,10 @@ export declare class ExtensionsService {
     extensionsItemService: ItemsService<ExtensionSettings>;
     extensionsManager: ExtensionManager;
     constructor(options: AbstractServiceOptions);
+    private preInstall;
     install(extensionId: string, versionId: string): Promise<void>;
+    uninstall(id: string): Promise<void>;
+    reinstall(id: string): Promise<void>;
     readAll(): Promise<ApiOutput[]>;
     readOne(id: string): Promise<ApiOutput>;
     updateOne(id: string, data: DeepPartial<ApiOutput>): Promise<ApiOutput>;

package/dist/services/extensions.js

@@ -4,6 +4,7 @@ import { describe } from '@directus/extensions-registry';
 import { isObject } from '@directus/utils';
 import getDatabase from '../database/index.js';
 import { getExtensionManager } from '../extensions/index.js';
+import { transaction } from '../utils/transaction.js';
 import { ItemsService } from './items.js';
 export class ExtensionReadError extends Error {
     originalError;
@@ -29,7 +30,7 @@ export class ExtensionsService {
             accountability: this.accountability,
         });
     }
-    async install(extensionId, versionId) {
+    async preInstall(extensionId, versionId) {
         const env = useEnv();
         const describeOptions = {};
         if (typeof env['MARKETPLACE_REGISTRY'] === 'string') {
@@ -54,6 +55,10 @@ export class ExtensionsService {
                 throw new LimitExceededError();
             }
         }
+        return { extension, version };
+    }
+    async install(extensionId, versionId) {
+        const { extension, version } = await this.preInstall(extensionId, versionId);
         await this.extensionsItemService.createOne({
             id: extensionId,
             enabled: true,
@@ -71,6 +76,38 @@ export class ExtensionsService {
         }
         await this.extensionsManager.install(versionId);
     }
+    async uninstall(id) {
+        const settings = await this.extensionsItemService.readOne(id);
+        if (settings.source !== 'registry') {
+            throw new InvalidPayloadError({
+                reason: 'Cannot uninstall extensions that were not installed via marketplace',
+            });
+        }
+        if (settings.bundle !== null) {
+            throw new InvalidPayloadError({
+                reason: 'Cannot uninstall sub extensions of bundles separately',
+            });
+        }
+        await this.deleteOne(id);
+        await this.extensionsManager.uninstall(settings.folder);
+    }
+    async reinstall(id) {
+        const settings = await this.extensionsItemService.readOne(id);
+        if (settings.source !== 'registry') {
+            throw new InvalidPayloadError({
+                reason: 'Cannot reinstall extensions that were not installed via marketplace',
+            });
+        }
+        if (settings.bundle !== null) {
+            throw new InvalidPayloadError({
+                reason: 'Cannot reinstall sub extensions of bundles separately',
+            });
+        }
+        const extensionId = settings.id;
+        const versionId = settings.folder;
+        await this.preInstall(extensionId, versionId);
+        await this.extensionsManager.install(versionId);
+    }
     async readAll() {
         const settings = await this.extensionsItemService.readByQuery({ limit: -1 });
         const regular = settings.filter(({ bundle }) => bundle === null);
@@ -111,7 +148,7 @@ export class ExtensionsService {
         };
     }
     async updateOne(id, data) {
-        const result = await this.knex.transaction(async (trx) => {
+        const result = await transaction(this.knex, async (trx) => {
             if (!isObject(data.meta)) {
                 throw new InvalidPayloadError({ reason: `"meta" is required` });
             }
@@ -133,19 +170,14 @@ export class ExtensionsService {
             }
             return extension;
         });
-        this.extensionsManager.reload();
+        this.extensionsManager.reload().then(() => {
+            this.extensionsManager.broadcastReloadNotification();
+        });
         return result;
     }
     async deleteOne(id) {
-        const settings = await this.extensionsItemService.readOne(id);
-        if (settings.source !== 'registry') {
-            throw new InvalidPayloadError({
-                reason: 'Cannot uninstall extensions that were not installed from the marketplace registry',
-            });
-        }
         await this.extensionsItemService.deleteOne(id);
         await this.extensionsItemService.deleteByQuery({ filter: { bundle: { _eq: id } } });
-        await this.extensionsManager.uninstall(settings.folder);
     }
     /**
      * Sync a bundles enabled status

package/dist/services/fields.d.ts

@@ -3,9 +3,9 @@ import type { Accountability, Field, RawField, SchemaOverview, Type } from '@dir
 import type Keyv from 'keyv';
 import type { Knex } from 'knex';
 import type { Helpers } from '../database/helpers/index.js';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 import { PayloadService } from './payload.js';
-import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 export declare class FieldsService {
     knex: Knex;
     helpers: Helpers;
@@ -26,6 +26,7 @@ export declare class FieldsService {
     }, table?: Knex.CreateTableBuilder, // allows collection creation to
     opts?: MutationOptions): Promise<void>;
     updateField(collection: string, field: RawField, opts?: MutationOptions): Promise<string>;
+    updateFields(collection: string, fields: RawField[], opts?: MutationOptions): Promise<string[]>;
     deleteField(collection: string, field: string, opts?: MutationOptions): Promise<void>;
     addColumnToTable(table: Knex.CreateTableBuilder, field: RawField | Field, alter?: Column | null): void;
 }

package/dist/services/fields.js

@@ -1,4 +1,5 @@
 import { KNEX_TYPES, REGEX_BETWEEN_PARENS } from '@directus/constants';
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
 import { addFieldFlag, toArray } from '@directus/utils';
 import { isEqual, isNil, merge } from 'lodash-es';
@@ -8,16 +9,16 @@ import { translateDatabaseError } from '../database/errors/translate.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
 import emitter from '../emitter.js';
-import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
-import { ItemsService } from './items.js';
-import { PayloadService } from './payload.js';
 import getDefaultValue from '../utils/get-default-value.js';
+import { getSystemFieldRowsWithAuthProviders } from '../utils/get-field-system-rows.js';
 import getLocalType from '../utils/get-local-type.js';
 import { getSchema } from '../utils/get-schema.js';
 import { sanitizeColumn } from '../utils/sanitize-schema.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
+import { transaction } from '../utils/transaction.js';
+import { ItemsService } from './items.js';
+import { PayloadService } from './payload.js';
 import { RelationsService } from './relations.js';
-import { getSystemFieldRowsWithAuthProviders } from '../utils/get-field-system-rows.js';
 const systemFieldRows = getSystemFieldRowsWithAuthProviders();
 export class FieldsService {
     knex;
@@ -218,7 +219,7 @@ export class FieldsService {
             if (flagToAdd) {
                 addFieldFlag(field, flagToAdd);
             }
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 const itemsService = new ItemsService('directus_fields', {
                     knex: trx,
                     accountability: this.accountability,
@@ -337,7 +338,7 @@ export class FieldsService {
                 const columnToCompare = opts?.bypassLimits && opts.autoPurgeSystemCache === false ? sanitizeColumn(existingColumn) : existingColumn;
                 if (!isEqual(columnToCompare, hookAdjustedField.schema)) {
                     try {
-                        await this.knex.transaction(async (trx) => {
+                        await transaction(this.knex, async (trx) => {
                             await trx.schema.alterTable(collection, async (table) => {
                                 if (!hookAdjustedField.schema)
                                     return;
@@ -406,6 +407,35 @@ export class FieldsService {
             }
         }
     }
+    async updateFields(collection, fields, opts) {
+        const nestedActionEvents = [];
+        try {
+            const fieldNames = [];
+            for (const field of fields) {
+                fieldNames.push(await this.updateField(collection, field, {
+                    autoPurgeCache: false,
+                    autoPurgeSystemCache: false,
+                    bypassEmitAction: (params) => nestedActionEvents.push(params),
+                }));
+            }
+            return fieldNames;
+        }
+        finally {
+            if (shouldClearCache(this.cache, opts)) {
+                await this.cache.clear();
+            }
+            if (opts?.autoPurgeSystemCache !== false) {
+                await clearSystemCache({ autoPurgeCache: opts?.autoPurgeCache });
+            }
+            if (opts?.emitEvents !== false && nestedActionEvents.length > 0) {
+                const updatedSchema = await getSchema();
+                for (const nestedActionEvent of nestedActionEvents) {
+                    nestedActionEvent.context.schema = updatedSchema;
+                    emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+                }
+            }
+        }
+    }
     async deleteField(collection, field, opts) {
         if (this.accountability && this.accountability.admin !== true) {
             throw new ForbiddenError();
@@ -422,7 +452,7 @@ export class FieldsService {
                     accountability: this.accountability,
                 });
             }
-            await this.knex.transaction(async (trx) => {
+            await transaction(this.knex, async (trx) => {
                 const relations = this.schema.relations.filter((relation) => {
                     return ((relation.collection === collection && relation.field === field) ||
                         (relation.related_collection === collection && relation.meta?.one_field === field));

package/dist/services/files.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { BusboyFileStream, File } from '@directus/types';
+import type { BusboyFileStream, File, PrimaryKey } from '@directus/types';
 import type { Readable } from 'node:stream';
-import type { AbstractServiceOptions, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 type Metadata = Partial<Pick<File, 'height' | 'width' | 'description' | 'title' | 'tags' | 'metadata'>>;
 export declare class FilesService extends ItemsService {

package/dist/services/flows.d.ts

@@ -1,5 +1,5 @@
-import type { FlowRaw } from '@directus/types';
-import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { FlowRaw, Item, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, MutationOptions } from '../types/index.js';
 import { ItemsService } from './items.js';
 export declare class FlowsService extends ItemsService<FlowRaw> {
     constructor(options: AbstractServiceOptions);

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

@@ -1,10 +1,10 @@
 import { type DirectusError } from '@directus/errors';
-import type { Accountability, Filter, Query, SchemaOverview } from '@directus/types';
+import type { Accountability, Filter, Item, Query, SchemaOverview } from '@directus/types';
 import type { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLResolveInfo, SelectionNode } from 'graphql';
 import { GraphQLError, GraphQLSchema } from 'graphql';
 import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
 import type { Knex } from 'knex';
-import type { AbstractServiceOptions, GraphQLParams, Item } from '../../types/index.js';
+import type { AbstractServiceOptions, GraphQLParams } from '../../types/index.js';
 export declare class GraphQLService {
     accountability: Accountability | null;
     knex: Knex;

package/dist/services/graphql/index.js

@@ -929,6 +929,11 @@ export class GraphQLService {
                         },
                     };
                 }
+                else {
+                    resolver.args = {
+                        version: GraphQLString,
+                    };
+                }
                 ReadCollectionTypes[collection.collection].addResolver(resolver);
                 ReadCollectionTypes[collection.collection].addResolver({
                     name: `${collection.collection}_aggregated`,

package/dist/services/import-export.js

@@ -16,6 +16,7 @@ import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import { useLogger } from '../logger.js';
 import { getDateFormatted } from '../utils/get-date-formatted.js';
+import { transaction } from '../utils/transaction.js';
 import { Url } from '../utils/url.js';
 import { userName } from '../utils/user-name.js';
 import { FilesService } from './files.js';
@@ -54,7 +55,7 @@ export class ImportService {
     importJSON(collection, stream) {
         const extractJSON = StreamArray.withParser();
         const nestedActionEvents = [];
-        return this.knex.transaction((trx) => {
+        return transaction(this.knex, (trx) => {
             const service = new ItemsService(collection, {
                 knex: trx,
                 schema: this.schema,
@@ -92,7 +93,7 @@ export class ImportService {
         if (!tmpFile)
             throw new Error('Failed to create temporary file for import');
         const nestedActionEvents = [];
-        return this.knex.transaction((trx) => {
+        return transaction(this.knex, (trx) => {
             const service = new ItemsService(collection, {
                 knex: trx,
                 schema: this.schema,
@@ -211,7 +212,7 @@ export class ExportService {
                 yaml: 'text/yaml',
             };
             const database = getDatabase();
-            await database.transaction(async (trx) => {
+            await transaction(database, async (trx) => {
                 const service = new ItemsService(collection, {
                     accountability: this.accountability,
                     schema: this.schema,

package/dist/services/items.d.ts

@@ -1,7 +1,7 @@
-import type { Accountability, PermissionsAction, Query, SchemaOverview } from '@directus/types';
+import type { Accountability, Item as AnyItem, PermissionsAction, PrimaryKey, Query, SchemaOverview } from '@directus/types';
 import type Keyv from 'keyv';
 import type { Knex } from 'knex';
-import type { AbstractService, AbstractServiceOptions, Item as AnyItem, MutationOptions, PrimaryKey } from '../types/index.js';
+import type { AbstractService, AbstractServiceOptions, MutationOptions } from '../types/index.js';
 export type QueryOptions = {
     stripNonRequested?: boolean;
     permissionsAction?: PermissionsAction;