@directus/api 32.2.0 → 33.1.0

package/dist/deployment/deployment.d.ts

@@ -0,0 +1,94 @@
+import type { Credentials, Deployment, Details, Log, Options, Project, TriggerResult } from '@directus/types';
+import type { AxiosRequestConfig, AxiosResponse } from 'axios';
+export type DeploymentRequestOptions = Pick<AxiosRequestConfig<string>, 'method' | 'headers'> & {
+    body?: string | null;
+    params?: Record<string, string>;
+};
+export declare abstract class DeploymentDriver<TCredentials extends Credentials = Credentials, TOptions extends Options = Options> {
+    credentials: TCredentials;
+    options: TOptions;
+    constructor(credentials: TCredentials, options?: TOptions);
+    protected axiosRequest<T>(apiUrl: string, endpoint: string, options?: DeploymentRequestOptions): Promise<AxiosResponse<T>>;
+    /**
+     * Test connection with provider using credentials
+     *
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     */
+    abstract testConnection(): Promise<void>;
+    /**
+     * List all available projects from provider
+     *
+     * @returns Array of external projects
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract listProjects(): Promise<Project[]>;
+    /**
+     * Get project details by ID
+     *
+     * @param projectId External project ID
+     * @returns Project details
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract getProject(projectId: string): Promise<Project>;
+    /**
+     * List deployments for a project
+     *
+     * @param projectId External project ID
+     * @param limit Number of deployments to return
+     * @returns Array of deployments
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract listDeployments(projectId: string, limit?: number): Promise<Deployment[]>;
+    /**
+     * Get deployment details including logs
+     *
+     * @param deploymentId External deployment ID
+     * @returns Deployment details with logs
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract getDeployment(deploymentId: string): Promise<Details>;
+    /**
+     * Trigger a new deployment
+     *
+     * @param projectId External project ID
+     * @param options Deployment options
+     * @returns Deployment result
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract triggerDeployment(projectId: string, options?: {
+        preview?: boolean;
+        clearCache?: boolean;
+    }): Promise<TriggerResult>;
+    /**
+     * Cancel a running deployment
+     *
+     * @param deploymentId External deployment ID
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract cancelDeployment(deploymentId: string): Promise<void>;
+    /**
+     * Get deployment build logs
+     *
+     * @param deploymentId External deployment ID
+     * @param options.since Only return logs after this timestamp
+     * @returns Array of log entries
+     * @throws {InvalidCredentialsError} When API credentials are invalid
+     * @throws {HitRateLimitError} When rate limit is exceeded
+     * @throws {ServiceUnavailableError} When provider API fails
+     */
+    abstract getDeploymentLogs(deploymentId: string, options?: {
+        since?: Date;
+    }): Promise<Log[]>;
+}

package/dist/deployment/deployment.js

@@ -0,0 +1,29 @@
+import { getAxios } from '../request/index.js';
+export class DeploymentDriver {
+    credentials;
+    options;
+    constructor(credentials, options = {}) {
+        this.credentials = credentials;
+        this.options = options;
+    }
+    async axiosRequest(apiUrl, endpoint, options = {}) {
+        const { params, ...requestOptions } = options;
+        const url = new URL(endpoint, apiUrl);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                url.searchParams.set(key, value);
+            }
+        }
+        const axios = await getAxios();
+        const requestConfig = {
+            url: url.toString(),
+            method: requestOptions.method ?? 'GET',
+            validateStatus: () => true,
+            headers: requestOptions.headers ?? {},
+        };
+        if (requestOptions.body) {
+            requestConfig.data = requestOptions.body;
+        }
+        return await axios.request(requestConfig);
+    }
+}

package/dist/deployment/drivers/index.d.ts

@@ -0,0 +1 @@
+export * from './vercel.js';

package/dist/deployment/drivers/index.js

@@ -0,0 +1 @@
+export * from './vercel.js';

package/dist/deployment/drivers/vercel.d.ts

@@ -0,0 +1,32 @@
+import type { Credentials, Deployment, Details, Log, Options, Project, TriggerResult } from '@directus/types';
+import { DeploymentDriver } from '../deployment.js';
+export interface VercelCredentials extends Credentials {
+    access_token: string;
+}
+export interface VercelOptions extends Options {
+    team_id?: string;
+}
+export declare class VercelDriver extends DeploymentDriver<VercelCredentials, VercelOptions> {
+    private static readonly API_URL;
+    private requestLimit;
+    constructor(credentials: VercelCredentials, options?: VercelOptions);
+    /**
+     * Make authenticated request with retry on rate limit and concurrency control
+     */
+    private request;
+    private mapStatus;
+    testConnection(): Promise<void>;
+    private mapProjectBase;
+    listProjects(): Promise<Project[]>;
+    getProject(projectId: string): Promise<Project>;
+    listDeployments(projectId: string, limit?: number): Promise<Deployment[]>;
+    getDeployment(deploymentId: string): Promise<Details>;
+    triggerDeployment(projectId: string, options?: {
+        preview?: boolean;
+        clearCache?: boolean;
+    }): Promise<TriggerResult>;
+    cancelDeployment(deploymentId: string): Promise<void>;
+    getDeploymentLogs(deploymentId: string, options?: {
+        since?: Date;
+    }): Promise<Log[]>;
+}

package/dist/deployment/drivers/vercel.js

@@ -0,0 +1,208 @@
+import { HitRateLimitError, InvalidCredentialsError, ServiceUnavailableError } from '@directus/errors';
+import pLimit from 'p-limit';
+import { DeploymentDriver } from '../deployment.js';
+export class VercelDriver extends DeploymentDriver {
+    static API_URL = 'https://api.vercel.com';
+    requestLimit = pLimit(5);
+    constructor(credentials, options = {}) {
+        super(credentials, options);
+    }
+    /**
+     * Make authenticated request with retry on rate limit and concurrency control
+     */
+    async request(endpoint, options = {}, retryCount = 0) {
+        return this.requestLimit(async () => {
+            const response = await this.axiosRequest(VercelDriver.API_URL, endpoint, {
+                ...options,
+                headers: {
+                    Authorization: `Bearer ${this.credentials.access_token}`,
+                    'Content-Type': 'application/json',
+                    ...(options.headers ?? {}),
+                },
+                params: {
+                    ...(this.options.team_id ? { teamId: this.options.team_id } : {}),
+                    ...(options.params ?? {}),
+                },
+            });
+            // Handle rate limiting with retry (max 3 retries)
+            if (response.status === 429) {
+                const resetAt = parseInt(response.headers['x-ratelimit-reset'] || '0');
+                const limit = parseInt(response.headers['x-ratelimit-limit'] || '0');
+                if (retryCount < 3) {
+                    const waitTime = resetAt > 0 ? Math.max(resetAt * 1000 - Date.now(), 1000) : 1000 * (retryCount + 1);
+                    await new Promise((resolve) => setTimeout(resolve, waitTime));
+                    return this.request(endpoint, options, retryCount + 1);
+                }
+                // Max retries exceeded
+                throw new HitRateLimitError({
+                    limit,
+                    reset: new Date(resetAt > 0 ? resetAt * 1000 : Date.now()),
+                });
+            }
+            const body = response.data;
+            if (response.status >= 400) {
+                const message = typeof body === 'object' && body !== null && 'error' in body
+                    ? body.error?.message || `Vercel API error: ${response.status}`
+                    : `Vercel API error: ${response.status}`;
+                if (response.status === 401 || response.status === 403) {
+                    throw new InvalidCredentialsError();
+                }
+                throw new ServiceUnavailableError({ service: 'vercel', reason: message });
+            }
+            return body;
+        });
+    }
+    mapStatus(vercelStatus) {
+        const normalized = vercelStatus?.toLowerCase();
+        switch (normalized) {
+            case 'building':
+            case 'error':
+            case 'canceled':
+            case 'ready':
+                return normalized;
+            case 'queued':
+            case 'initializing':
+            case 'analyzing':
+            case 'deploying':
+            default:
+                return 'building';
+        }
+    }
+    async testConnection() {
+        return await this.request('/v9/projects', { params: { limit: '1' } });
+    }
+    mapProjectBase(project) {
+        const result = {
+            id: project.id,
+            name: project.name,
+            deployable: Boolean(project.link?.type),
+        };
+        if (project.framework) {
+            result.framework = project.framework;
+        }
+        return result;
+    }
+    async listProjects() {
+        const response = await this.request('/v9/projects');
+        return response.projects.map((project) => this.mapProjectBase(project));
+    }
+    async getProject(projectId) {
+        const project = await this.request(`/v9/projects/${projectId}`);
+        const result = this.mapProjectBase(project);
+        const production = project.targets?.production;
+        if (production?.alias?.[0]) {
+            result.url = `https://${production.alias[0]}`;
+        }
+        // Latest deployment info from detail endpoint
+        if (production?.readyState && production.createdAt) {
+            result.latest_deployment = {
+                status: this.mapStatus(production.readyState),
+                created_at: new Date(production.createdAt),
+                ...(production.readyAt && { finished_at: new Date(production.readyAt) }),
+            };
+        }
+        if (project.createdAt) {
+            result.created_at = new Date(project.createdAt);
+        }
+        if (project.updatedAt) {
+            result.updated_at = new Date(project.updatedAt);
+        }
+        return result;
+    }
+    async listDeployments(projectId, limit = 20) {
+        const url = `/v6/deployments?projectId=${encodeURIComponent(projectId)}&limit=${limit}`;
+        const response = await this.request(url);
+        return response.deployments.map((deployment) => {
+            const result = {
+                id: deployment.uid,
+                project_id: deployment.projectId ?? projectId,
+                status: this.mapStatus(deployment.state),
+                created_at: new Date(deployment.createdAt),
+            };
+            if (deployment.url) {
+                result.url = `https://${deployment.url}`;
+            }
+            if (deployment.ready) {
+                result.finished_at = new Date(deployment.ready);
+            }
+            return result;
+        });
+    }
+    async getDeployment(deploymentId) {
+        const deployment = await this.request(`/v13/deployments/${encodeURIComponent(deploymentId)}`);
+        const result = {
+            id: deployment.id,
+            project_id: deployment.projectId ?? '',
+            status: this.mapStatus(deployment.status || deployment.state),
+            created_at: new Date(deployment.createdAt),
+        };
+        if (deployment.url) {
+            result.url = `https://${deployment.url}`;
+        }
+        if (deployment.ready) {
+            result.finished_at = new Date(deployment.ready);
+        }
+        return result;
+    }
+    async triggerDeployment(projectId, options) {
+        // Fetch project to get realtime required name needed for the vercel request
+        const project = await this.request(`/v9/projects/${projectId}`);
+        const body = {
+            name: project.name,
+            project: projectId,
+        };
+        if (!options?.preview) {
+            body['target'] = 'production';
+        }
+        // Add required gitSource
+        if (project.link?.type) {
+            body['gitSource'] = {
+                type: project.link.type,
+                ref: project.link.productionBranch,
+                repoId: project.link.repoId,
+            };
+        }
+        // forceNew=1 skips build cache when clearCache is true
+        const response = await this.request('/v13/deployments', {
+            method: 'POST',
+            body: JSON.stringify(body),
+            ...(options?.clearCache && { params: { forceNew: '1' } }),
+        });
+        const triggerResult = {
+            deployment_id: response.id,
+            status: this.mapStatus(response.status),
+        };
+        if (response.url) {
+            triggerResult.url = `https://${response.url}`;
+        }
+        return triggerResult;
+    }
+    async cancelDeployment(deploymentId) {
+        await this.request(`/v12/deployments/${encodeURIComponent(deploymentId)}/cancel`, {
+            method: 'PATCH',
+        });
+    }
+    async getDeploymentLogs(deploymentId, options) {
+        let url = `/v3/deployments/${encodeURIComponent(deploymentId)}/events`;
+        // Vercel's since parameter uses milliseconds timestamp
+        if (options?.since) {
+            const sinceMs = options.since.getTime();
+            url += `?since=${sinceMs}`;
+        }
+        const response = await this.request(url);
+        const mapEventType = (type) => {
+            if (type === 'stderr')
+                return 'stderr';
+            if (type === 'command')
+                return 'info';
+            return 'stdout';
+        };
+        return response
+            .filter((event) => event.type === 'stdout' || event.type === 'stderr' || event.type === 'command')
+            .map((event) => ({
+            timestamp: new Date(event.created),
+            type: mapEventType(event.type),
+            message: event.text || event.payload?.text || '',
+        }));
+    }
+}

package/dist/deployment/index.d.ts

@@ -0,0 +1,2 @@
+export * from './deployment.js';
+export * from './drivers/index.js';

package/dist/deployment/index.js

@@ -0,0 +1,2 @@
+export * from './deployment.js';
+export * from './drivers/index.js';

package/dist/deployment.d.ts

@@ -0,0 +1,24 @@
+import type { Credentials, Options, ProviderType } from '@directus/types';
+import type { DeploymentDriver } from './deployment/deployment.js';
+/**
+ * Register all deployment drivers
+ */
+export declare function registerDeploymentDrivers(): void;
+/**
+ * Get a deployment driver instance
+ *
+ * @param provider Provider name (vercel, netlify, aws, etc.)
+ * @param credentials Provider credentials (decrypted from DB)
+ * @param options Additional provider options
+ * @returns Deployment driver instance
+ * @throws Error if provider is not supported
+ */
+export declare function getDeploymentDriver(provider: ProviderType, credentials: Credentials, options?: Options): DeploymentDriver;
+/**
+ * Check if a provider is supported
+ */
+export declare function isValidProviderType(provider: string): provider is ProviderType;
+/**
+ * Get list of supported provider types
+ */
+export declare function getSupportedProviderTypes(): ProviderType[];

package/dist/deployment.js

@@ -0,0 +1,39 @@
+import { VercelDriver } from './deployment/drivers/index.js';
+/**
+ * Registry of deployment driver constructors
+ */
+const drivers = new Map();
+/**
+ * Register all deployment drivers
+ */
+export function registerDeploymentDrivers() {
+    drivers.set('vercel', VercelDriver);
+}
+/**
+ * Get a deployment driver instance
+ *
+ * @param provider Provider name (vercel, netlify, aws, etc.)
+ * @param credentials Provider credentials (decrypted from DB)
+ * @param options Additional provider options
+ * @returns Deployment driver instance
+ * @throws Error if provider is not supported
+ */
+export function getDeploymentDriver(provider, credentials, options) {
+    const Driver = drivers.get(provider);
+    if (!Driver) {
+        throw new Error(`Deployment driver "${provider}" is not supported`);
+    }
+    return new Driver(credentials, options);
+}
+/**
+ * Check if a provider is supported
+ */
+export function isValidProviderType(provider) {
+    return drivers.has(provider);
+}
+/**
+ * Get list of supported provider types
+ */
+export function getSupportedProviderTypes() {
+    return Array.from(drivers.keys());
+}

package/dist/extensions/lib/get-extensions-path.js

@@ -1,5 +1,5 @@
-import { useEnv } from '@directus/env';
 import { join } from 'path';
+import { useEnv } from '@directus/env';
 export const getExtensionsPath = () => {
     const env = useEnv();
     if (env['EXTENSIONS_LOCATION']) {

package/dist/extensions/lib/get-extensions-settings.js

@@ -1,8 +1,8 @@
 import { randomUUID } from 'node:crypto';
+import { list } from '@directus/extensions-registry';
 import getDatabase from '../../database/index.js';
 import { ExtensionsService } from '../../services/extensions.js';
 import { getSchema } from '../../utils/get-schema.js';
-import { list } from '@directus/extensions-registry';
 /**
  * Loads stored settings for all extensions. Creates empty new rows in extensions tables for
  * extensions that don't have settings yet, and remove any settings for extensions that are no

package/dist/extensions/lib/get-extensions.js

@@ -1,6 +1,6 @@
+import { join } from 'node:path';
 import { useEnv } from '@directus/env';
 import { resolveFsExtensions, resolveModuleExtensions } from '@directus/extensions/node';
-import { join } from 'node:path';
 import { getExtensionsPath } from './get-extensions-path.js';
 export const getExtensions = async () => {
     const env = useEnv();

package/dist/extensions/lib/get-shared-deps-mapping.js

@@ -1,10 +1,10 @@
-import { useEnv } from '@directus/env';
-import { resolvePackage } from '@directus/utils/node';
-import { escapeRegExp } from 'lodash-es';
 import { readdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
+import { useEnv } from '@directus/env';
+import { resolvePackage } from '@directus/utils/node';
+import { escapeRegExp } from 'lodash-es';
 import { useLogger } from '../../logger/index.js';
 import { Url } from '../../utils/url.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));

package/dist/extensions/lib/installation/manager.js

@@ -1,13 +1,13 @@
+import { mkdir, readFile, rm } from 'node:fs/promises';
+import { Readable } from 'node:stream';
+import { join } from 'path';
 import { useEnv } from '@directus/env';
 import { ErrorCode, isDirectusError, ServiceUnavailableError } from '@directus/errors';
 import { EXTENSION_PKG_KEY, ExtensionManifest } from '@directus/extensions';
 import { download } from '@directus/extensions-registry';
 import DriverLocal from '@directus/storage-driver-local';
 import { move, remove } from 'fs-extra';
-import { mkdir, readFile, rm } from 'node:fs/promises';
-import { Readable } from 'node:stream';
 import Queue from 'p-queue';
-import { join } from 'path';
 import { extract } from 'tar';
 import { useLogger } from '../../../logger/index.js';
 import { getStorage } from '../../../storage/index.js';

package/dist/extensions/lib/sandbox/register/route.d.ts

@@ -1,6 +1,6 @@
+import type { IncomingHttpHeaders } from 'node:http';
 import type { Router } from 'express';
 import type { Reference } from 'isolated-vm';
-import type { IncomingHttpHeaders } from 'node:http';
 export declare function registerRouteGenerator(endpointName: string, endpointRouter: Router): {
     register: (path: Reference<string>, method: Reference<"GET" | "POST" | "PUT" | "PATCH" | "DELETE">, cb: Reference<(req: {
         url: string;

package/dist/extensions/lib/sync/status.js

@@ -1,9 +1,9 @@
 /**
  * Utility functions to write a `.status` file on the filesystem to indicate active synchronization
  */
+import { rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { exists } from 'fs-extra';
-import { writeFile, rm } from 'node:fs/promises';
 import { getExtensionsPath } from '../get-extensions-path.js';
 export const SyncStatus = {
     SYNCING: 'SYNCING',

package/dist/extensions/lib/sync/sync.js

@@ -1,19 +1,19 @@
-import Queue from 'p-queue';
-import mid from 'node-machine-id';
-import { useEnv } from '@directus/env';
 import { createWriteStream } from 'node:fs';
 import { mkdir, rm } from 'node:fs/promises';
-import { pipeline } from 'node:stream/promises';
 import { dirname, join, relative, resolve, sep } from 'node:path';
-import { getSyncPaths, compareFileMetadata } from './utils.js';
+import { pipeline } from 'node:stream/promises';
+import { useEnv } from '@directus/env';
+import { normalizePath } from '@directus/utils';
+import mid from 'node-machine-id';
+import Queue from 'p-queue';
 import { useBus } from '../../../bus/index.js';
-import { SyncFileTracker } from './tracker.js';
 import { useLock } from '../../../lock/index.js';
 import { useLogger } from '../../../logger/index.js';
 import { getStorage } from '../../../storage/index.js';
 import { getExtensionsPath } from '../get-extensions-path.js';
 import { isSynchronizing, setSyncStatus, SyncStatus } from './status.js';
-import { normalizePath } from '@directus/utils';
+import { SyncFileTracker } from './tracker.js';
+import { compareFileMetadata, getSyncPaths } from './utils.js';
 export async function syncExtensions(options) {
     if (options?.skipSync === true)
         return;

package/dist/extensions/lib/sync/utils.js

@@ -1,8 +1,8 @@
-import { join, relative, resolve, sep } from 'node:path';
 import { stat } from 'node:fs/promises';
-import { getExtensionsPath } from '../get-extensions-path.js';
+import { join, relative, resolve, sep } from 'node:path';
 import { useEnv } from '@directus/env';
 import { normalizePath } from '@directus/utils';
+import { getExtensionsPath } from '../get-extensions-path.js';
 /**
  * Returns the directory depth of the provided path
  */

package/dist/extensions/manager.d.ts

@@ -1,6 +1,6 @@
+import type { ReadStream } from 'node:fs';
 import type { Extension, ExtensionManagerOptions } from '@directus/types';
 import { Router } from 'express';
-import type { ReadStream } from 'node:fs';
 import { type ExtensionSyncOptions } from './lib/sync/sync.js';
 export declare class ExtensionManager {
     private options;

package/dist/extensions/manager.js

@@ -1,7 +1,13 @@
+import { readdir, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import path from 'path';
+import { HYBRID_EXTENSION_TYPES } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { APP_SHARED_DEPS } from '@directus/extensions';
-import { HYBRID_EXTENSION_TYPES } from '@directus/constants';
 import { generateExtensionsEntrypoint } from '@directus/extensions/node';
+import DriverLocal from '@directus/storage-driver-local';
 import { isTypeIn, toBoolean } from '@directus/utils';
 import { pathToRelativeUrl, processId } from '@directus/utils/node';
 import aliasDefault from '@rollup/plugin-alias';
@@ -11,11 +17,6 @@ import chokidar, { FSWatcher } from 'chokidar';
 import express, { Router } from 'express';
 import ivm from 'isolated-vm';
 import { clone, debounce, isPlainObject } from 'lodash-es';
-import { readFile, readdir } from 'node:fs/promises';
-import os from 'node:os';
-import { dirname, join, relative, resolve, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import path from 'path';
 import { rolldown } from 'rolldown';
 import { rollup } from 'rollup';
 import { useBus } from '../bus/index.js';
@@ -37,9 +38,8 @@ import { getSharedDepsMapping } from './lib/get-shared-deps-mapping.js';
 import { getInstallationManager } from './lib/installation/index.js';
 import { generateApiExtensionsSandboxEntrypoint } from './lib/sandbox/generate-api-extensions-sandbox-entrypoint.js';
 import { instantiateSandboxSdk } from './lib/sandbox/sdk/instantiate.js';
-import { wrapEmbeds } from './lib/wrap-embeds.js';
-import DriverLocal from '@directus/storage-driver-local';
 import { syncExtensions } from './lib/sync/sync.js';
+import { wrapEmbeds } from './lib/wrap-embeds.js';
 // Workaround for https://github.com/rollup/plugins/issues/1329
 const virtual = virtualDefault;
 const alias = aliasDefault;

package/dist/flows.d.ts

@@ -1,4 +1,4 @@
-import type { Accountability, SchemaOverview, OperationHandler } from '@directus/types';
+import type { Accountability, OperationHandler, SchemaOverview } from '@directus/types';
 export declare function getFlowManager(): FlowManager;
 declare class FlowManager {
     private isLoaded;

package/dist/logger/index.js

@@ -1,7 +1,7 @@
+import { URL } from 'node:url';
 import { useEnv } from '@directus/env';
 import { REDACTED_TEXT, toArray, toBoolean } from '@directus/utils';
 import { merge } from 'lodash-es';
-import { URL } from 'node:url';
 import { pino } from 'pino';
 import { pinoHttp, stdSerializers } from 'pino-http';
 import { httpPrintFactory } from 'pino-http-print';

package/dist/logger/logs-stream.d.ts

@@ -1,5 +1,5 @@
-import type { Bus } from '@directus/memory';
 import { Writable } from 'stream';
+import type { Bus } from '@directus/memory';
 type PrettyType = 'basic' | 'http' | false;
 export declare class LogsStream extends Writable {
     messenger: Bus;

package/dist/logger/logs-stream.js

@@ -1,5 +1,5 @@
-import { nanoid } from 'nanoid';
 import { Writable } from 'stream';
+import { nanoid } from 'nanoid';
 import { useBus } from '../bus/index.js';
 const nodeId = nanoid(8);
 export class LogsStream extends Writable {

package/dist/mailer.js

@@ -1,8 +1,8 @@
+import { createRequire } from 'node:module';
 import { useEnv } from '@directus/env';
 import nodemailer from 'nodemailer';
 import { useLogger } from './logger/index.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
-import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 let transporter;
 export default function getMailer() {