@directus/api 32.1.1 → 33.0.0

package/dist/database/migrations/20240806A-permissions-policies.js

@@ -1,13 +1,13 @@
+import { randomUUID } from 'node:crypto';
 import { processChunk, toBoolean } from '@directus/utils';
 import { omit } from 'lodash-es';
-import { randomUUID } from 'node:crypto';
 import { useLogger } from '../../logger/index.js';
 import { fetchPermissions } from '../../permissions/lib/fetch-permissions.js';
 import { fetchPolicies } from '../../permissions/lib/fetch-policies.js';
 import { fetchRolesTree } from '../../permissions/lib/fetch-roles-tree.js';
+import { mergePermissions } from '../../permissions/utils/merge-permissions.js';
 import { getSchema } from '../../utils/get-schema.js';
 import { getSchemaInspector } from '../index.js';
-import { mergePermissions } from '../../permissions/utils/merge-permissions.js';
 async function fetchRoleAccess(roles, context) {
     const roleAccess = {
         admin_access: false,
@@ -184,7 +184,7 @@ export async function down(knex) {
     // role permissions to be inserted once all processing is completed
     const rolePermissions = [];
     for (const role of roles) {
-        const roleTree = await fetchRolesTree(role.id, knex);
+        const roleTree = await fetchRolesTree(role.id, { knex });
         let roleAccess = null;
         if (role.id !== null) {
             roleAccess = await fetchRoleAccess(roleTree, context);

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

@@ -1,5 +1,5 @@
-import { Action } from '@directus/constants';
 import { randomUUID } from 'node:crypto';
+import { Action } from '@directus/constants';
 export async function up(knex) {
     // remove foreign key constraint for projects already migrated to retentions-p1
     try {

package/dist/database/migrations/20251014A-add-project-owner.js

@@ -1,8 +1,8 @@
 import { useEnv } from '@directus/env';
 import { toBoolean } from '@directus/utils';
+import { email } from 'zod';
 import { SettingsService } from '../../services/settings.js';
 import { getSchema } from '../../utils/get-schema.js';
-import { email } from 'zod';
 export async function up(knex) {
     await knex.schema.alterTable('directus_settings', (table) => {
         table.string('project_owner');

package/dist/database/migrations/20251103A-add-ai-settings.d.ts

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

package/dist/database/migrations/20251103A-add-ai-settings.js

@@ -0,0 +1,14 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.text('ai_openai_api_key');
+        table.text('ai_anthropic_api_key');
+        table.text('ai_system_prompt');
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('ai_openai_api_key');
+        table.dropColumn('ai_anthropic_api_key');
+        table.dropColumn('ai_system_prompt');
+    });
+}

package/dist/database/migrations/20251224A-remove-webhooks.d.ts

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

package/dist/database/migrations/20251224A-remove-webhooks.js

@@ -0,0 +1,19 @@
+export async function up(knex) {
+    await knex.schema.dropTable('directus_webhooks');
+}
+export async function down(knex) {
+    await knex.schema.createTable('directus_webhooks', (table) => {
+        table.increments('id');
+        table.string('name', 255).notNullable();
+        table.string('method', 10).notNullable().defaultTo('POST');
+        table.text('url').notNullable();
+        table.string('status', 10).notNullable().defaultTo('active');
+        table.boolean('data').notNullable().defaultTo(true);
+        table.string('actions', 100).notNullable();
+        table.text('collections').notNullable();
+        table.json('headers');
+        table.boolean('was_active_before_deprecation').notNullable().defaultTo(false);
+        table.uuid('migrated_flow');
+        table.foreign('migrated_flow').references('directus_flows.id').onDelete('SET NULL');
+    });
+}

package/dist/database/migrations/20260113A-add-revisions-index.d.ts

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

package/dist/database/migrations/20260113A-add-revisions-index.js

@@ -0,0 +1,41 @@
+import { FieldsService } from '../../services/fields.js';
+import { getSchema } from '../../utils/get-schema.js';
+import { transaction } from '../../utils/transaction.js';
+import { getHelpers } from '../helpers/index.js';
+import { getDatabaseClient } from '../index.js';
+const RETENTION_INDEXES = [
+    // MySQL and MariaDB are ignored because they already have an index on revisions.activity
+    { collection: 'directus_revisions', field: 'activity', ignore: ['mysql', 'mariadb'] },
+];
+export async function up(knex) {
+    const client = getDatabaseClient(knex);
+    const helpers = getHelpers(knex);
+    const schema = await getSchema();
+    const service = new FieldsService({ knex, schema });
+    for (const { collection, field, ignore } of RETENTION_INDEXES) {
+        if (ignore.includes(client))
+            continue;
+        const existingColumn = await service.columnInfo(collection, field);
+        if (!existingColumn.is_indexed) {
+            await helpers.schema.createIndex(collection, field, { attemptConcurrentIndex: true });
+        }
+    }
+}
+export async function down(knex) {
+    const client = getDatabaseClient(knex);
+    const helpers = getHelpers(knex);
+    const schema = await getSchema();
+    const service = new FieldsService({ knex, schema });
+    for (const { collection, field, ignore } of RETENTION_INDEXES) {
+        if (ignore.includes(client))
+            continue;
+        const existingColumn = await service.columnInfo(collection, field);
+        if (existingColumn.is_indexed) {
+            await transaction(knex, async (trx) => {
+                await trx.schema.alterTable(collection, async (table) => {
+                    table.dropIndex([field], helpers.schema.generateIndexName('index', collection, field));
+                });
+            });
+        }
+    }
+}

package/dist/database/migrations/run.js

@@ -1,10 +1,10 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import path from 'path';
 import { useEnv } from '@directus/env';
 import formatTitle from '@directus/format-title';
 import fse from 'fs-extra';
 import { orderBy } from 'lodash-es';
-import { dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import path from 'path';
 import { flushCaches } from '../../cache.js';
 import { useLogger } from '../../logger/index.js';
 import getModuleDefault from '../../utils/get-module-default.js';

package/dist/database/run-ast/lib/apply-query/filter/get-filter-type.d.ts

@@ -1,8 +1,8 @@
 import type { FieldOverview } from '@directus/types';
 export declare function getFilterType(fields: Record<string, FieldOverview>, key: string, collection?: string): {
-    type: "string" | "boolean" | "binary" | "time" | "text" | "integer" | "float" | "alias" | "uuid" | "dateTime" | "timestamp" | "bigInteger" | "date" | "decimal" | "json" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon" | "unknown";
+    type: "string" | "boolean" | "binary" | "text" | "unknown" | "integer" | "date" | "float" | "alias" | "uuid" | "time" | "dateTime" | "timestamp" | "bigInteger" | "decimal" | "json" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon";
     special?: never;
 } | {
-    type: "string" | "boolean" | "binary" | "time" | "text" | "integer" | "float" | "alias" | "uuid" | "dateTime" | "timestamp" | "bigInteger" | "date" | "decimal" | "json" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon" | "unknown";
+    type: "string" | "boolean" | "binary" | "text" | "unknown" | "integer" | "date" | "float" | "alias" | "uuid" | "time" | "dateTime" | "timestamp" | "bigInteger" | "decimal" | "json" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon";
     special: string[];
 };

package/dist/database/run-ast/lib/apply-query/filter/get-filter-type.js

@@ -1,6 +1,6 @@
-import { parseFilterKey } from '../../../../../utils/parse-filter-key.js';
 import { InvalidQueryError } from '@directus/errors';
 import { getFunctionsForType, getOutputTypeForFunction } from '@directus/utils';
+import { parseFilterKey } from '../../../../../utils/parse-filter-key.js';
 export function getFilterType(fields, key, collection = 'unknown') {
     const { fieldName, functionName } = parseFilterKey(key);
     const field = fields[fieldName];

package/dist/database/run-ast/lib/apply-query/filter/operator.js

@@ -1,6 +1,6 @@
-import { getColumn } from '../../../utils/get-column.js';
 import { getOutputTypeForFunction } from '@directus/utils';
 import { getHelpers } from '../../../../helpers/index.js';
+import { getColumn } from '../../../utils/get-column.js';
 export function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logical = 'and', originalCollectionName) {
     const helpers = getHelpers(knex);
     const [table, column] = key.split('.');

package/dist/database/run-ast/lib/apply-query/sort.js

@@ -1,6 +1,6 @@
 import { getColumnPath } from '../../../../utils/get-column-path.js';
-import { getColumn } from '../../utils/get-column.js';
 import { getRelationInfo } from '../../../../utils/get-relation-info.js';
+import { getColumn } from '../../utils/get-column.js';
 import { addJoin } from './add-join.js';
 export function applySort(knex, schema, rootQuery, sort, aggregate, collection, aliasMap, returnRecords = false) {
     const relations = schema.relations;

package/dist/database/run-ast/run-ast.js

@@ -48,7 +48,7 @@ export async function runAst(originalAST, schema, accountability, options) {
         if (!rawItems)
             return null;
         // Run the items through the special transforms
-        const payloadService = new PayloadService(collection, { knex, schema });
+        const payloadService = new PayloadService(collection, { accountability, knex, schema });
         let items = await payloadService.processValues('read', rawItems, query.alias ?? {}, query.aggregate ?? {});
         if (!items || (Array.isArray(items) && items.length === 0))
             return items;

package/dist/database/run-ast/utils/get-column-pre-processor.js

@@ -1,8 +1,8 @@
-import { joinFilterWithCases } from '../lib/apply-query/join-filter-with-cases.js';
-import { getColumn } from './get-column.js';
 import { parseFilterKey } from '../../../utils/parse-filter-key.js';
 import { getHelpers } from '../../helpers/index.js';
+import { joinFilterWithCases } from '../lib/apply-query/join-filter-with-cases.js';
 import { applyCaseWhen } from './apply-case-when.js';
+import { getColumn } from './get-column.js';
 import { getNodeAlias } from './get-field-alias.js';
 export function getColumnPreprocessor(knex, schema, table, cases, permissions, aliasMap, permissionsOnly) {
     const helpers = getHelpers(knex);

package/dist/database/run-ast/utils/get-column.js

@@ -1,7 +1,7 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
+import { InvalidQueryError } from '@directus/errors';
 import { getFunctionsForType } from '@directus/utils';
 import { getFunctions } from '../../helpers/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/database/seeds/run.js

@@ -1,9 +1,9 @@
-import fse from 'fs-extra';
-import yaml from 'js-yaml';
-import { isObject } from 'lodash-es';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
+import fse from 'fs-extra';
+import yaml from 'js-yaml';
+import { isObject } from 'lodash-es';
 import { getHelpers } from '../helpers/index.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export default async function runSeed(database) {

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';
@@ -63,11 +63,9 @@ export class InstallationManager {
                 }
                 await queue.onIdle();
             }
-            else {
-                // No custom location, so save to regular local extensions folder
-                const dest = join(this.extensionPath, '.registry', versionId);
-                await move(join(tempDir, extractedPath), dest, { overwrite: true });
-            }
+            // move to regular local extensions folder
+            const dest = join(this.extensionPath, '.registry', versionId);
+            await move(join(tempDir, extractedPath), dest, { overwrite: true });
         }
         catch (err) {
             logger.warn(err);
@@ -92,9 +90,7 @@ export class InstallationManager {
             }
             await queue.onIdle();
         }
-        else {
-            const path = join(this.extensionPath, '.registry', folder);
-            await remove(path);
-        }
+        const path = join(this.extensionPath, '.registry', folder);
+        await remove(path);
     }
 }

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.d.ts

@@ -0,0 +1,11 @@
+export declare const SyncStatus: {
+    readonly SYNCING: "SYNCING";
+    readonly IDLE: "IDLE";
+};
+export type SyncStatus = keyof typeof SyncStatus;
+export declare function getSyncStatus(): Promise<SyncStatus>;
+export declare function setSyncStatus(status: SyncStatus): Promise<void>;
+/**
+ * Checks the filesystem lock file if we are currently synchronizing
+ */
+export declare function isSynchronizing(): Promise<boolean>;

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

@@ -0,0 +1,34 @@
+/**
+ * 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 { getExtensionsPath } from '../get-extensions-path.js';
+export const SyncStatus = {
+    SYNCING: 'SYNCING',
+    IDLE: 'IDLE',
+};
+export async function getSyncStatus() {
+    const statusFilePath = join(getExtensionsPath(), '.status');
+    if (await exists(statusFilePath)) {
+        return SyncStatus.SYNCING;
+    }
+    return SyncStatus.IDLE;
+}
+export async function setSyncStatus(status) {
+    const statusFilePath = join(getExtensionsPath(), '.status');
+    if (status === SyncStatus.SYNCING) {
+        await writeFile(statusFilePath, '');
+    }
+    else {
+        await rm(statusFilePath);
+    }
+}
+/**
+ * Checks the filesystem lock file if we are currently synchronizing
+ */
+export async function isSynchronizing() {
+    const status = await getSyncStatus();
+    return status === SyncStatus.SYNCING;
+}

package/dist/extensions/lib/sync/sync.d.ts

@@ -0,0 +1,6 @@
+export type ExtensionSyncOptions = {
+    forceSync?: boolean;
+    partialSync?: string;
+    skipSync?: boolean;
+};
+export declare function syncExtensions(options?: ExtensionSyncOptions): Promise<void>;

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

@@ -0,0 +1,90 @@
+import { createWriteStream } from 'node:fs';
+import { mkdir, rm } from 'node:fs/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+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 { 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 { SyncFileTracker } from './tracker.js';
+import { compareFileMetadata, getSyncPaths } from './utils.js';
+export async function syncExtensions(options) {
+    if (options?.skipSync === true)
+        return;
+    const env = useEnv();
+    const lock = useLock();
+    const messenger = useBus();
+    const logger = useLogger();
+    if (options?.forceSync !== true && (await isSynchronizing())) {
+        logger.debug('Extensions are already being synced to this directory from another process.');
+        return;
+    }
+    const machineId = await mid.machineId();
+    const machineKey = `extensions-sync/${machineId}`;
+    const processId = await lock.increment(machineKey);
+    if (processId !== 1) {
+        logger.debug('Extensions are already being synced to this machine from another process.');
+        // Wait until the process that called the lock publishes a message that the syncing is complete
+        return new Promise((resolve) => {
+            messenger.subscribe(machineKey, () => resolve());
+        });
+    }
+    try {
+        logger.debug('Syncing extensions from configured storage location...');
+        // Ensure that the local extensions cache path exists
+        await mkdir(getExtensionsPath(), { recursive: true });
+        await setSyncStatus(SyncStatus.SYNCING);
+        const { localExtensionsPath, remoteExtensionsPath } = getSyncPaths(options?.partialSync);
+        const storage = await getStorage();
+        const disk = storage.location(env['EXTENSIONS_LOCATION']);
+        // check if we are only removing the local directory
+        if (options?.partialSync) {
+            const remoteExists = await disk.exists(normalizePath(join(remoteExtensionsPath, 'package.json')));
+            if (remoteExists === false) {
+                await rm(localExtensionsPath, { recursive: true, force: true });
+                return;
+            }
+        }
+        // Make sure we don't overload the file handles
+        const queue = new Queue({ concurrency: 1000 });
+        // start file tracker
+        const fileTracker = new SyncFileTracker();
+        const localFileCount = await fileTracker.readLocalFiles(localExtensionsPath);
+        const hasLocalFiles = localFileCount > 0;
+        for await (const filepath of disk.list(remoteExtensionsPath)) {
+            // We want files to be stored in the root of `$TEMP_PATH/extensions`, so gotta remove the
+            // extensions path on disk from the start of the file path
+            const relativePath = relative(resolve(sep, remoteExtensionsPath), resolve(sep, filepath));
+            const destinationPath = join(localExtensionsPath, relativePath);
+            await fileTracker.passedFile(relativePath);
+            // No need to check metadata when force is enabled
+            if (options?.forceSync !== true && hasLocalFiles) {
+                const fileUnchanged = await compareFileMetadata(destinationPath, filepath, disk);
+                if (fileUnchanged)
+                    continue;
+            }
+            // Ensure that the directory path exists
+            await mkdir(dirname(destinationPath), { recursive: true });
+            // write remote file to the local filesystem
+            const readStream = await disk.read(filepath);
+            const writeStream = createWriteStream(destinationPath);
+            queue.add(() => pipeline(readStream, writeStream));
+        }
+        // wait for the queue to finish
+        await queue.onIdle();
+        // cleanup dangling local files
+        await fileTracker.cleanup(localExtensionsPath);
+    }
+    finally {
+        // release various locking mechanisms
+        messenger.publish(machineKey, { ready: true });
+        await lock.delete(machineKey);
+        await setSyncStatus(SyncStatus.IDLE);
+    }
+}

package/dist/extensions/lib/sync/tracker.d.ts

@@ -0,0 +1,18 @@
+export declare class SyncFileTracker {
+    private localFiles;
+    private trackedDirs;
+    constructor();
+    /**
+     * Reads all files recusrively in the provided directory
+     * @returns the number of files read
+     */
+    readLocalFiles(localExtensionsPath: string): Promise<number>;
+    /**
+     * Removes a file from the locally tracked files
+     */
+    passedFile(filePath: string): Promise<void>;
+    /**
+     * Removes left over tracked files that were not processed
+     */
+    cleanup(localExtensionsPath: string): Promise<void>;
+}

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

@@ -0,0 +1,71 @@
+/**
+ * class to help tracking file status between local and remote
+ */
+import { readdir, rm } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { pathDepth } from './utils.js';
+export class SyncFileTracker {
+    localFiles;
+    trackedDirs;
+    constructor() {
+        this.localFiles = new Set();
+        this.trackedDirs = new Set();
+    }
+    /**
+     * Reads all files recusrively in the provided directory
+     * @returns the number of files read
+     */
+    async readLocalFiles(localExtensionsPath) {
+        const entries = await readdir(localExtensionsPath, { recursive: true, withFileTypes: true }).catch(() => {
+            /* path doesnt exist */
+        });
+        if (!entries)
+            return 0;
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const relativePath = join(relative(localExtensionsPath, entry.parentPath), entry.name);
+            this.localFiles.add(relativePath);
+        }
+        return this.localFiles.size;
+    }
+    /**
+     * Removes a file from the locally tracked files
+     */
+    async passedFile(filePath) {
+        this.localFiles.delete(filePath);
+        let currentDir = dirname(filePath);
+        while (currentDir !== '.') {
+            if (this.trackedDirs.has(currentDir))
+                break;
+            this.trackedDirs.add(currentDir);
+            currentDir = dirname(currentDir);
+        }
+    }
+    /**
+     * Removes left over tracked files that were not processed
+     */
+    async cleanup(localExtensionsPath) {
+        const removeDirs = new Set();
+        for (const removeFile of this.localFiles) {
+            if (removeFile === '.status')
+                continue;
+            let currentDir = dirname(removeFile);
+            while (currentDir !== localExtensionsPath && currentDir !== '.') {
+                if (this.trackedDirs.has(currentDir))
+                    break;
+                removeDirs.add(currentDir);
+                currentDir = dirname(currentDir);
+            }
+        }
+        // sort directory by depth so we can remove the highest level directory recursively
+        const removeDirsRecursive = Array.from(removeDirs)
+            .sort((a, b) => pathDepth(b) - pathDepth(a))
+            .filter((d) => !removeDirs.has(dirname(d)));
+        for (const dir of removeDirsRecursive) {
+            const relativePath = join(localExtensionsPath, dir);
+            // removing local folder that does not exist in the remote storage
+            await rm(relativePath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/extensions/lib/sync/utils.d.ts

@@ -0,0 +1,24 @@
+import type { Driver } from '@directus/storage';
+/**
+ * Returns the directory depth of the provided path
+ */
+export declare function pathDepth(path: string): number;
+/**
+ * Reads the size and modified date of a file if it exists
+ */
+export declare function fsStat(path: string): Promise<{
+    size: number;
+    modified: Date;
+} | null>;
+/**
+ * Builds up the local and remote paths to use with syncing
+ */
+export declare function getSyncPaths(partialPath: string | undefined): {
+    localExtensionsPath: string;
+    remoteExtensionsPath: string;
+};
+/**
+ * Retrieve the stats for local and remote files and check if they are the same
+ * Returns false if files are differnt else true
+ */
+export declare function compareFileMetadata(localPath: string, remotePath: string, disk: Driver): Promise<boolean>;