@directus/api 32.2.0 → 33.1.0

package/dist/services/collections.js

@@ -14,10 +14,10 @@ import { validateAccess } from '../permissions/modules/validate-access/validate-
 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 { buildCollectionAndFieldRelations } from './fields/build-collection-and-field-relations.js';
 import { getCollectionMetaUpdates } from './fields/get-collection-meta-updates.js';
 import { getCollectionRelationList } from './fields/get-collection-relation-list.js';
+import { FieldsService } from './fields.js';
 import { ItemsService } from './items.js';
 export class CollectionsService {
     knex;

package/dist/services/deployment-projects.d.ts

@@ -0,0 +1,20 @@
+import type { AbstractServiceOptions, PrimaryKey } from '@directus/types';
+import { ItemsService } from './items.js';
+export interface DeploymentProject {
+    id: string;
+    deployment: string;
+    external_id: string;
+    name: string;
+    date_created: string;
+    user_created: string;
+}
+export declare class DeploymentProjectsService extends ItemsService<DeploymentProject> {
+    constructor(options: AbstractServiceOptions);
+    /**
+     * Update project selection (create/delete)
+     */
+    updateSelection(deploymentId: string, create: {
+        external_id: string;
+        name: string;
+    }[], deleteIds: PrimaryKey[]): Promise<DeploymentProject[]>;
+}

package/dist/services/deployment-projects.js

@@ -0,0 +1,34 @@
+import getDatabase from '../database/index.js';
+import { transaction } from '../utils/transaction.js';
+import { ItemsService } from './items.js';
+export class DeploymentProjectsService extends ItemsService {
+    constructor(options) {
+        super('directus_deployment_projects', options);
+    }
+    /**
+     * Update project selection (create/delete)
+     */
+    async updateSelection(deploymentId, create, deleteIds) {
+        const db = getDatabase();
+        return transaction(db, async (trx) => {
+            const trxService = new DeploymentProjectsService({
+                accountability: this.accountability,
+                schema: this.schema,
+                knex: trx,
+            });
+            if (deleteIds.length > 0) {
+                await trxService.deleteMany(deleteIds);
+            }
+            if (create.length > 0) {
+                await trxService.createMany(create.map((p) => ({
+                    deployment: deploymentId,
+                    external_id: p.external_id,
+                    name: p.name,
+                })));
+            }
+            return trxService.readByQuery({
+                filter: { deployment: { _eq: deploymentId } },
+            });
+        });
+    }
+}

package/dist/services/deployment-runs.d.ts

@@ -0,0 +1,13 @@
+import type { AbstractServiceOptions } from '@directus/types';
+import { ItemsService } from './items.js';
+export interface DeploymentRun {
+    id: string;
+    project: string;
+    external_id: string;
+    target: string;
+    date_created: string;
+    user_created: string;
+}
+export declare class DeploymentRunsService extends ItemsService<DeploymentRun> {
+    constructor(options: AbstractServiceOptions);
+}

package/dist/services/deployment-runs.js

@@ -0,0 +1,6 @@
+import { ItemsService } from './items.js';
+export class DeploymentRunsService extends ItemsService {
+    constructor(options) {
+        super('directus_deployment_runs', options);
+    }
+}

package/dist/services/deployment.d.ts

@@ -0,0 +1,40 @@
+import type { AbstractServiceOptions, CachedResult, DeploymentConfig, PrimaryKey, Project, ProviderType, Query } from '@directus/types';
+import type { DeploymentDriver } from '../deployment/deployment.js';
+import { ItemsService } from './items.js';
+export declare class DeploymentService extends ItemsService<DeploymentConfig> {
+    constructor(options: AbstractServiceOptions);
+    createOne(data: Partial<DeploymentConfig>, opts?: any): Promise<PrimaryKey>;
+    updateOne(key: PrimaryKey, data: Partial<DeploymentConfig>, opts?: any): Promise<PrimaryKey>;
+    /**
+     * Read deployment config by provider
+     */
+    readByProvider(provider: ProviderType, query?: Query): Promise<DeploymentConfig>;
+    /**
+     * Update deployment config by provider
+     */
+    updateByProvider(provider: ProviderType, data: Partial<DeploymentConfig>): Promise<PrimaryKey>;
+    /**
+     * Delete deployment config by provider
+     */
+    deleteByProvider(provider: ProviderType): Promise<PrimaryKey>;
+    /**
+     * Read deployment config with decrypted credentials (internal use)
+     */
+    private readConfig;
+    /**
+     * Parse JSON string or return value as-is
+     */
+    private parseValue;
+    /**
+     * Get a deployment driver instance with decrypted credentials
+     */
+    getDriver(provider: ProviderType): Promise<DeploymentDriver>;
+    /**
+     * List projects from provider with caching
+     */
+    listProviderProjects(provider: ProviderType): Promise<CachedResult<Project[]>>;
+    /**
+     * Get project details from provider with caching
+     */
+    getProviderProject(provider: ProviderType, projectId: string): Promise<CachedResult<Project>>;
+}

package/dist/services/deployment.js

@@ -0,0 +1,202 @@
+import { useEnv } from '@directus/env';
+import { InvalidPayloadError, InvalidProviderConfigError } from '@directus/errors';
+import { mergeFilters, parseJSON } from '@directus/utils';
+import { has, isEmpty } from 'lodash-es';
+import { getCache, getCacheValueWithTTL, setCacheValueWithExpiry } from '../cache.js';
+import { getDeploymentDriver } from '../deployment.js';
+import { getMilliseconds } from '../utils/get-milliseconds.js';
+import { ItemsService } from './items.js';
+const env = useEnv();
+const DEPLOYMENT_CACHE_TTL = getMilliseconds(env['CACHE_DEPLOYMENT_TTL']) || 5000; // Default 5s
+export class DeploymentService extends ItemsService {
+    constructor(options) {
+        super('directus_deployments', options);
+    }
+    async createOne(data, opts) {
+        const provider = data.provider;
+        if (!provider) {
+            throw new InvalidPayloadError({ reason: 'Provider is required' });
+        }
+        if (isEmpty(data.credentials)) {
+            throw new InvalidPayloadError({ reason: 'Credentials are required' });
+        }
+        let credentials;
+        try {
+            credentials = this.parseValue(data.credentials, {});
+        }
+        catch {
+            throw new InvalidPayloadError({ reason: 'Credentials must be valid JSON' });
+        }
+        let options;
+        try {
+            options = this.parseValue(data.options, undefined);
+        }
+        catch {
+            throw new InvalidPayloadError({ reason: 'Options must be valid JSON' });
+        }
+        // Test connection before persisting
+        const driver = getDeploymentDriver(provider, credentials, options);
+        try {
+            await driver.testConnection();
+        }
+        catch {
+            throw new InvalidProviderConfigError({ provider, reason: 'Invalid config connection' });
+        }
+        const payload = {
+            ...data,
+            // Persist as string so payload service encrypts the value
+            credentials: JSON.stringify(credentials),
+        };
+        if (!isEmpty(options)) {
+            payload.options = JSON.stringify(options);
+        }
+        return super.createOne(payload, opts);
+    }
+    async updateOne(key, data, opts) {
+        const hasCredentials = has(data, 'credentials');
+        const hasOptions = has(data, 'options');
+        if (!hasCredentials && !hasOptions) {
+            return super.updateOne(key, data, opts);
+        }
+        const existing = await this.readOne(key);
+        const provider = existing.provider;
+        const internal = await this.readConfig(provider);
+        let credentials = this.parseValue(internal.credentials, {});
+        if (hasCredentials) {
+            try {
+                const parsed = this.parseValue(data.credentials, {});
+                credentials = { ...credentials, ...parsed };
+            }
+            catch {
+                throw new InvalidPayloadError({ reason: 'Credentials must be valid JSON or object' });
+            }
+        }
+        let options = existing.options ?? undefined;
+        if (hasOptions) {
+            try {
+                options = this.parseValue(data.options, undefined);
+            }
+            catch {
+                throw new InvalidPayloadError({ reason: 'Options must be valid JSON' });
+            }
+            if (isEmpty(options)) {
+                throw new InvalidPayloadError({ reason: 'Options must not be empty' });
+            }
+        }
+        // Test connection before persisting
+        const driver = getDeploymentDriver(provider, credentials, options);
+        try {
+            await driver.testConnection();
+        }
+        catch {
+            throw new InvalidProviderConfigError({ provider, reason: 'Invalid config connection' });
+        }
+        return super.updateOne(key, {
+            credentials: JSON.stringify(credentials),
+            ...(!isEmpty(options) ? { options: JSON.stringify(options) } : {}),
+        }, opts);
+    }
+    /**
+     * Read deployment config by provider
+     */
+    async readByProvider(provider, query) {
+        const results = await this.readByQuery({
+            ...query,
+            filter: mergeFilters({ provider: { _eq: provider } }, query?.filter ?? null),
+            limit: 1,
+        });
+        if (!results || results.length === 0) {
+            throw new Error(`Deployment config for "${provider}" not found`);
+        }
+        return results[0];
+    }
+    /**
+     * Update deployment config by provider
+     */
+    async updateByProvider(provider, data) {
+        const deployment = await this.readByProvider(provider);
+        return this.updateOne(deployment.id, data);
+    }
+    /**
+     * Delete deployment config by provider
+     */
+    async deleteByProvider(provider) {
+        const deployment = await this.readByProvider(provider);
+        return this.deleteOne(deployment.id);
+    }
+    /**
+     * Read deployment config with decrypted credentials (internal use)
+     */
+    async readConfig(provider) {
+        const internalService = new ItemsService('directus_deployments', {
+            knex: this.knex,
+            schema: this.schema,
+            accountability: null,
+        });
+        const results = await internalService.readByQuery({
+            filter: { provider: { _eq: provider } },
+            limit: 1,
+        });
+        if (!results || results.length === 0) {
+            throw new Error(`Deployment config for "${provider}" not found`);
+        }
+        return results[0];
+    }
+    /**
+     * Parse JSON string or return value as-is
+     */
+    parseValue(value, fallback) {
+        if (!value)
+            return fallback;
+        if (typeof value === 'string')
+            return parseJSON(value);
+        return value;
+    }
+    /**
+     * Get a deployment driver instance with decrypted credentials
+     */
+    async getDriver(provider) {
+        const deployment = await this.readConfig(provider);
+        const credentials = this.parseValue(deployment.credentials, {});
+        const options = this.parseValue(deployment.options, {});
+        return getDeploymentDriver(deployment.provider, credentials, options);
+    }
+    /**
+     * List projects from provider with caching
+     */
+    async listProviderProjects(provider) {
+        const cacheKey = `${provider}:projects`;
+        const { deploymentCache } = getCache();
+        // Check cache first
+        const cached = await getCacheValueWithTTL(deploymentCache, cacheKey);
+        if (cached) {
+            return { data: cached.data, remainingTTL: cached.remainingTTL };
+        }
+        // Fetch from driver
+        const driver = await this.getDriver(provider);
+        const projects = await driver.listProjects();
+        // Store in cache
+        await setCacheValueWithExpiry(deploymentCache, cacheKey, projects, DEPLOYMENT_CACHE_TTL);
+        // Return with full TTL (just cached)
+        return { data: projects, remainingTTL: DEPLOYMENT_CACHE_TTL };
+    }
+    /**
+     * Get project details from provider with caching
+     */
+    async getProviderProject(provider, projectId) {
+        const cacheKey = `${provider}:project:${projectId}`;
+        const { deploymentCache } = getCache();
+        // Check cache first
+        const cached = await getCacheValueWithTTL(deploymentCache, cacheKey);
+        if (cached) {
+            return { data: cached.data, remainingTTL: cached.remainingTTL };
+        }
+        // Fetch from driver
+        const driver = await this.getDriver(provider);
+        const project = await driver.getProject(projectId);
+        // Store in cache
+        await setCacheValueWithExpiry(deploymentCache, cacheKey, project, DEPLOYMENT_CACHE_TTL);
+        // Return with full TTL (just cached)
+        return { data: project, remainingTTL: DEPLOYMENT_CACHE_TTL };
+    }
+}

package/dist/services/extensions.d.ts

@@ -1,4 +1,4 @@
-import type { ApiOutput, ExtensionSettings, ExtensionManager } from '@directus/types';
+import type { ApiOutput, ExtensionManager, ExtensionSettings } from '@directus/types';
 import type { AbstractServiceOptions, Accountability, DeepPartial, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import { ItemsService } from './items.js';

package/dist/services/files/utils/get-metadata.d.ts

@@ -1,4 +1,4 @@
-import type { File } from '@directus/types';
 import type { Readable } from 'node:stream';
+import type { File } from '@directus/types';
 export type Metadata = Partial<Pick<File, 'height' | 'width' | 'description' | 'title' | 'tags' | 'metadata'>>;
 export declare function getMetadata(stream: Readable, allowList?: string | string[]): Promise<Metadata>;

package/dist/services/files/utils/get-metadata.js

@@ -1,8 +1,8 @@
+import { pipeline } from 'node:stream/promises';
 import { useEnv } from '@directus/env';
 import exif, {} from 'exif-reader';
 import { parse as parseIcc } from 'icc';
 import { pick } from 'lodash-es';
-import { pipeline } from 'node:stream/promises';
 import { useLogger } from '../../../logger/index.js';
 import { getSharpInstance } from '../lib/get-sharp-instance.js';
 import { parseIptc, parseXmp } from './parse-image-metadata.js';

package/dist/services/files.d.ts

@@ -1,5 +1,5 @@
-import type { AbstractServiceOptions, BusboyFileStream, File, MutationOptions, PrimaryKey, Query, QueryOptions } from '@directus/types';
 import type { Readable } from 'node:stream';
+import type { AbstractServiceOptions, BusboyFileStream, File, MutationOptions, PrimaryKey, Query, QueryOptions } from '@directus/types';
 import { ItemsService } from './items.js';
 export declare class FilesService extends ItemsService<File> {
     constructor(options: AbstractServiceOptions);

package/dist/services/files.js

@@ -1,3 +1,7 @@
+import { PassThrough as PassThroughStream, Transform as TransformStream } from 'node:stream';
+import zlib from 'node:zlib';
+import path from 'path';
+import url from 'url';
 import { useEnv } from '@directus/env';
 import { ContentTooLargeError, InvalidPayloadError, ServiceUnavailableError } from '@directus/errors';
 import formatTitle from '@directus/format-title';
@@ -5,10 +9,6 @@ import { toArray } from '@directus/utils';
 import encodeURL from 'encodeurl';
 import { clone, cloneDeep } from 'lodash-es';
 import { extension } from 'mime-types';
-import { PassThrough as PassThroughStream, Transform as TransformStream } from 'node:stream';
-import zlib from 'node:zlib';
-import path from 'path';
-import url from 'url';
 import { RESUMABLE_UPLOADS } from '../constants.js';
 import emitter from '../emitter.js';
 import { useLogger } from '../logger/index.js';

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

@@ -1,4 +1,4 @@
-import type { AbstractServiceOptions, Accountability, GraphQLParams, GQLScope, Item, Query, SchemaOverview, PrimaryKey } from '@directus/types';
+import type { AbstractServiceOptions, Accountability, GQLScope, GraphQLParams, Item, PrimaryKey, Query, SchemaOverview } from '@directus/types';
 import type { FormattedExecutionResult, GraphQLSchema } from 'graphql';
 import type { Knex } from 'knex';
 export declare class GraphQLService {

package/dist/services/graphql/index.js

@@ -1,5 +1,5 @@
 import { useEnv } from '@directus/env';
-import { NoSchemaIntrospectionCustomRule, execute, specifiedRules, validate } from 'graphql';
+import { execute, NoSchemaIntrospectionCustomRule, specifiedRules, validate } from 'graphql';
 import getDatabase from '../../database/index.js';
 import { getService } from '../../utils/get-service.js';
 import { formatError } from './errors/format.js';

package/dist/services/graphql/resolvers/mutation.js

@@ -1,7 +1,7 @@
 import { getService } from '../../../utils/get-service.js';
 import { formatError } from '../errors/format.js';
-import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
 import { getQuery } from '../schema/parse-query.js';
+import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
 export async function resolveMutation(gql, args, info) {
     const action = info.fieldName.split('_')[0];
     let collection = info.fieldName.substring(action.length + 1);

package/dist/services/graphql/resolvers/system-admin.js

@@ -2,7 +2,6 @@ import { InvalidPayloadError } from '@directus/errors';
 import { isSystemField } from '@directus/system-data';
 import { GraphQLBoolean, GraphQLID, GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql';
 import { SchemaComposer, toInputObjectType } from 'graphql-compose';
-import { fromZodError } from 'zod-validation-error';
 import { CollectionsService } from '../../collections.js';
 import { ExtensionsService } from '../../extensions.js';
 import { FieldsService, systemFieldUpdateSchema } from '../../fields.js';
@@ -112,7 +111,7 @@ export function resolveSystemAdmin(gql, schema, schemaComposer) {
                 if (isSystemField(args['collection'], args['field'])) {
                     const validationResult = systemFieldUpdateSchema.safeParse(args['data']);
                     if (!validationResult.success) {
-                        throw new InvalidPayloadError({ reason: fromZodError(validationResult.error).message });
+                        throw new InvalidPayloadError({ reason: 'Only "schema.is_indexed" may be modified for system fields' });
                     }
                 }
                 await service.updateField(args['collection'], {
@@ -140,7 +139,7 @@ export function resolveSystemAdmin(gql, schema, schemaComposer) {
                     if (isSystemField(args['collection'], fieldData['field'])) {
                         const validationResult = systemFieldUpdateSchema.safeParse(fieldData);
                         if (!validationResult.success) {
-                            throw new InvalidPayloadError({ reason: fromZodError(validationResult.error).message });
+                            throw new InvalidPayloadError({ reason: 'Only "schema.is_indexed" may be modified for system fields' });
                         }
                     }
                 }

package/dist/services/graphql/schema/get-types.d.ts

@@ -1,6 +1,6 @@
+import type { GQLScope } from '@directus/types';
 import type { SchemaComposer } from 'graphql-compose';
 import { ObjectTypeComposer } from 'graphql-compose';
-import type { GQLScope } from '@directus/types';
 import { type InconsistentFields, type Schema } from './index.js';
 /**
  * Construct an object of types for every collection, using the permitted fields per action type

package/dist/services/graphql/schema/read.js

@@ -9,8 +9,8 @@ import { GraphQLDate } from '../types/date.js';
 import { GraphQLGeoJSON } from '../types/geojson.js';
 import { GraphQLHash } from '../types/hash.js';
 import { GraphQLStringOrFloat } from '../types/string-or-float.js';
-import { SYSTEM_DENY_LIST } from './index.js';
 import { getTypes } from './get-types.js';
+import { SYSTEM_DENY_LIST } from './index.js';
 /**
  * Create readable types and attach resolvers for each. Also prepares full filter argument structures
  */

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

@@ -1,5 +1,5 @@
-import type { GraphQLService } from './index.js';
 import type { GraphQLResolveInfo } from 'graphql';
+import type { GraphQLService } from './index.js';
 export declare function bindPubSub(): void;
 export declare function createSubscriptionGenerator(gql: GraphQLService, event: string): (_x: unknown, _y: unknown, _z: unknown, request: GraphQLResolveInfo) => AsyncGenerator<{
     [event]: {

package/dist/services/graphql/types/date.js

@@ -1,4 +1,4 @@
-import { GraphQLString, GraphQLScalarType } from 'graphql';
+import { GraphQLScalarType, GraphQLString } from 'graphql';
 export const GraphQLDate = new GraphQLScalarType({
     ...GraphQLString,
     name: 'Date',

package/dist/services/graphql/types/hash.js

@@ -1,4 +1,4 @@
-import { GraphQLString, GraphQLScalarType } from 'graphql';
+import { GraphQLScalarType, GraphQLString } from 'graphql';
 export const GraphQLHash = new GraphQLScalarType({
     ...GraphQLString,
     name: 'Hash',

package/dist/services/graphql/utils/add-path-to-validation-error.js

@@ -1,4 +1,4 @@
-import { GraphQLError, Token, locatedError } from 'graphql';
+import { GraphQLError, locatedError, Token } from 'graphql';
 export function addPathToValidationError(validationError) {
     const token = validationError.nodes?.[0]?.loc?.startToken;
     if (!token)

package/dist/services/graphql/utils/filter-replace-m2a.js

@@ -1,5 +1,4 @@
-import { getRelation } from '@directus/utils';
-import { getRelationType } from '../../../utils/get-relation-type.js';
+import { getRelation, getRelationType } from '@directus/utils';
 export function filterReplaceM2A(filter_arg, collection, schema, options) {
     const filter = filter_arg;
     for (const key in filter) {
@@ -10,7 +9,7 @@ export function filterReplaceM2A(filter_arg, collection, schema, options) {
             continue;
         field = options?.aliasMap?.[field] ?? field;
         const relation = getRelation(schema.relations, collection, field);
-        const type = relation ? getRelationType({ relation, collection, field }) : null;
+        const type = relation ? getRelationType({ relation, collection, field, useA2O: true }) : null;
         if (type === 'o2m' && relation) {
             filter[key] = filterReplaceM2A(filter[key], relation.collection, schema, options);
         }
@@ -46,7 +45,7 @@ export function filterReplaceM2ADeep(deep_arg, collection, schema, options) {
             const relation = getRelation(schema.relations, collection, field);
             if (!relation)
                 continue;
-            const type = getRelationType({ relation, collection, field });
+            const type = getRelationType({ relation, collection, field, useA2O: true });
             if (type === 'o2m') {
                 deep[key] = filterReplaceM2ADeep(deep[key], relation.collection, schema);
             }

package/dist/services/import-export.d.ts

@@ -1,6 +1,6 @@
+import type { Readable } from 'node:stream';
 import type { AbstractServiceOptions, Accountability, DirectusError, ExportFormat, File, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
-import type { Readable } from 'node:stream';
 import type { FieldNode, FunctionFieldNode, NestedCollectionNode } from '../types/index.js';
 export declare function createErrorTracker(): {
     addCapturedError: (err: any, rowNumber: number) => void;

package/dist/services/import-export.js

@@ -1,3 +1,5 @@
+import { createReadStream, createWriteStream } from 'node:fs';
+import { appendFile } from 'node:fs/promises';
 import { useEnv } from '@directus/env';
 import { createError, ErrorCode, ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '@directus/errors';
 import { isSystemCollection } from '@directus/system-data';
@@ -9,8 +11,6 @@ import { dump as toYAML } from 'js-yaml';
 import { parse as toXML } from 'js2xmlparser';
 import { Parser as CSVParser, transforms as CSVTransforms } from 'json2csv';
 import { set } from 'lodash-es';
-import { createReadStream, createWriteStream } from 'node:fs';
-import { appendFile } from 'node:fs/promises';
 import Papa from 'papaparse';
 import StreamArray from 'stream-json/streamers/StreamArray.js';
 import { parseFields } from '../database/get-ast-from-query/lib/parse-fields.js';

package/dist/services/index.d.ts

@@ -10,6 +10,9 @@ export * from './fields.js';
 export * from './files.js';
 export * from './flows.js';
 export * from './folders.js';
+export * from './deployment.js';
+export * from './deployment-projects.js';
+export * from './deployment-runs.js';
 export * from './graphql/index.js';
 export * from './import-export.js';
 export * from './items.js';
@@ -35,5 +38,4 @@ export * from './translations.js';
 export * from './users.js';
 export * from './utils.js';
 export * from './versions.js';
-export * from './webhooks.js';
 export * from './websocket.js';

package/dist/services/index.js

@@ -10,6 +10,9 @@ export * from './fields.js';
 export * from './files.js';
 export * from './flows.js';
 export * from './folders.js';
+export * from './deployment.js';
+export * from './deployment-projects.js';
+export * from './deployment-runs.js';
 export * from './graphql/index.js';
 export * from './import-export.js';
 export * from './items.js';
@@ -35,5 +38,4 @@ export * from './translations.js';
 export * from './users.js';
 export * from './utils.js';
 export * from './versions.js';
-export * from './webhooks.js';
 export * from './websocket.js';

package/dist/services/mail/index.js

@@ -1,10 +1,10 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { useEnv } from '@directus/env';
 import { InvalidPayloadError } from '@directus/errors';
 import { isObject } from '@directus/utils';
 import fse from 'fs-extra';
 import { Liquid } from 'liquidjs';
-import path from 'path';
-import { fileURLToPath } from 'url';
 import getDatabase from '../../database/index.js';
 import emitter from '../../emitter.js';
 import { useLogger } from '../../logger/index.js';

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

@@ -1,8 +1,8 @@
 import { useEnv } from '@directus/env';
+import { EmailLimitExceededError } from '@directus/errors';
+import { toBoolean } from '@directus/utils';
 import { RateLimiterQueue } from 'rate-limiter-flexible';
 import { createRateLimiter } from '../../rate-limiter.js';
-import { toBoolean } from '@directus/utils';
-import { EmailLimitExceededError } from '@directus/errors';
 let emailRateLimiterQueue;
 const env = useEnv();
 if (toBoolean(env['RATE_LIMITER_EMAIL_ENABLED']) === true) {

package/dist/services/payload.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { UserIntegrityCheckFlag } from '@directus/types';
 import { parseJSON, toArray } from '@directus/utils';
@@ -5,12 +6,11 @@ import { format, isValid, parseISO } from 'date-fns';
 import { unflatten } from 'flat';
 import Joi from 'joi';
 import { clone, cloneDeep, isNil, isObject, isPlainObject, pick } from 'lodash-es';
-import { randomUUID } from 'node:crypto';
 import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
-import { generateHash } from '../utils/generate-hash.js';
 import { decrypt, encrypt } from '../utils/encrypt.js';
+import { generateHash } from '../utils/generate-hash.js';
 import { getSecret } from '../utils/get-secret.js';
 /**
  * Process a given payload for a collection to ensure the special fields (hash, uuid, date etc) are

package/dist/services/schema.js

@@ -1,5 +1,5 @@
-import getDatabase from '../database/index.js';
 import { ForbiddenError } from '@directus/errors';
+import getDatabase from '../database/index.js';
 import { applyDiff } from '../utils/apply-diff.js';
 import { getSnapshotDiff } from '../utils/get-snapshot-diff.js';
 import { getSnapshot } from '../utils/get-snapshot.js';