@directus/api 34.0.1 → 35.0.0

package/dist/auth.js

@@ -1,65 +1,71 @@
-import { useEnv } from '@directus/env';
-import { InvalidProviderConfigError } from '@directus/errors';
-import { toArray } from '@directus/utils';
-import { LDAPAuthDriver, LocalAuthDriver, OAuth2AuthDriver, OpenIDAuthDriver, SAMLAuthDriver, } from './auth/drivers/index.js';
-import { DEFAULT_AUTH_PROVIDER } from './constants.js';
-import getDatabase from './database/index.js';
-import { useLogger } from './logger/index.js';
-import { getConfigFromEnv } from './utils/get-config-from-env.js';
+import { getConfigFromEnv } from "./utils/get-config-from-env.js";
+import { useLogger } from "./logger/index.js";
+import { DEFAULT_AUTH_PROVIDER } from "./constants.js";
+import database_default from "./database/index.js";
+import { LocalAuthDriver } from "./auth/drivers/local.js";
+import { OAuth2AuthDriver } from "./auth/drivers/oauth2.js";
+import { OpenIDAuthDriver } from "./auth/drivers/openid.js";
+import { LDAPAuthDriver } from "./auth/drivers/ldap.js";
+import { SAMLAuthDriver } from "./auth/drivers/saml.js";
+import "./auth/drivers/index.js";
+import { useEnv } from "@directus/env";
+import { InvalidProviderConfigError } from "@directus/errors";
+import { toArray } from "@directus/utils";
+
+//#region src/auth.ts
 const providers = new Map();
-export function getAuthProvider(provider) {
-    const logger = useLogger();
-    if (!providers.has(provider)) {
-        logger.error('Auth provider not configured');
-        throw new InvalidProviderConfigError({ provider });
-    }
-    return providers.get(provider);
+function getAuthProvider(provider) {
+	const logger = useLogger();
+	if (!providers.has(provider)) {
+		logger.error("Auth provider not configured");
+		throw new InvalidProviderConfigError({ provider });
+	}
+	return providers.get(provider);
 }
-export async function registerAuthProviders() {
-    const env = useEnv();
-    const logger = useLogger();
-    const options = { knex: getDatabase() };
-    const providerNames = toArray(env['AUTH_PROVIDERS']);
-    // Register default provider if not disabled
-    if (!env['AUTH_DISABLE_DEFAULT']) {
-        const defaultProvider = getProviderInstance('local', options);
-        providers.set(DEFAULT_AUTH_PROVIDER, defaultProvider);
-    }
-    if (!env['AUTH_PROVIDERS']) {
-        return;
-    }
-    // Register configured providers
-    providerNames.forEach((name) => {
-        name = name.trim();
-        if (name === DEFAULT_AUTH_PROVIDER) {
-            logger.error(`Cannot override "${DEFAULT_AUTH_PROVIDER}" auth provider.`);
-            process.exit(1);
-        }
-        const { driver, ...config } = getConfigFromEnv(`AUTH_${name.toUpperCase()}_`);
-        if (!driver) {
-            logger.warn(`Missing driver definition for "${name}" auth provider.`);
-            return;
-        }
-        const provider = getProviderInstance(driver, options, { provider: name, ...config });
-        if (!provider) {
-            logger.warn(`Invalid "${driver}" auth driver.`);
-            return;
-        }
-        providers.set(name, provider);
-    });
+async function registerAuthProviders() {
+	const env = useEnv();
+	const logger = useLogger();
+	const options = { knex: database_default() };
+	const providerNames = toArray(env["AUTH_PROVIDERS"]);
+	if (!env["AUTH_DISABLE_DEFAULT"]) {
+		const defaultProvider = getProviderInstance("local", options);
+		providers.set(DEFAULT_AUTH_PROVIDER, defaultProvider);
+	}
+	if (!env["AUTH_PROVIDERS"]) {
+		return;
+	}
+	providerNames.forEach((name) => {
+		name = name.trim();
+		if (name === DEFAULT_AUTH_PROVIDER) {
+			logger.error(`Cannot override "${DEFAULT_AUTH_PROVIDER}" auth provider.`);
+			process.exit(1);
+		}
+		const { driver,...config } = getConfigFromEnv(`AUTH_${name.toUpperCase()}_`);
+		if (!driver) {
+			logger.warn(`Missing driver definition for "${name}" auth provider.`);
+			return;
+		}
+		const provider = getProviderInstance(driver, options, {
+			provider: name,
+			...config
+		});
+		if (!provider) {
+			logger.warn(`Invalid "${driver}" auth driver.`);
+			return;
+		}
+		providers.set(name, provider);
+	});
 }
 function getProviderInstance(driver, options, config = {}) {
-    switch (driver) {
-        case 'local':
-            return new LocalAuthDriver(options, config);
-        case 'oauth2':
-            return new OAuth2AuthDriver(options, config);
-        case 'openid':
-            return new OpenIDAuthDriver(options, config);
-        case 'ldap':
-            return new LDAPAuthDriver(options, config);
-        case 'saml':
-            return new SAMLAuthDriver(options, config);
-    }
-    return undefined;
+	switch (driver) {
+		case "local": return new LocalAuthDriver(options, config);
+		case "oauth2": return new OAuth2AuthDriver(options, config);
+		case "openid": return new OpenIDAuthDriver(options, config);
+		case "ldap": return new LDAPAuthDriver(options, config);
+		case "saml": return new SAMLAuthDriver(options, config);
+	}
+	return undefined;
 }
+
+//#endregion
+export { getAuthProvider, registerAuthProviders };

package/dist/bus/index.js

@@ -1 +1,3 @@
-export { useBus } from './lib/use-bus.js';
+import { useBus } from "./lib/use-bus.js";
+
+export { useBus };

package/dist/bus/lib/use-bus.js

@@ -1,21 +1,31 @@
-import { createBus } from '@directus/memory';
-import { redisConfigAvailable, useRedis } from '../../redis/index.js';
-export const _cache = {
-    bus: undefined,
-};
+import { useRedis } from "../../redis/lib/use-redis.js";
+import { redisConfigAvailable } from "../../redis/utils/redis-config-available.js";
+import "../../redis/index.js";
+import { useEnv } from "@directus/env";
+import { createBus } from "@directus/memory";
+
+//#region src/bus/lib/use-bus.ts
+const _cache = { bus: undefined };
 /**
- * Returns globally shared message bus. If Redis is available, will use a redis-driven pub/sub bus.
- * Otherwise will default to a local-only bus.
- */
-export const useBus = () => {
-    if (_cache.bus) {
-        return _cache.bus;
-    }
-    if (redisConfigAvailable()) {
-        _cache.bus = createBus({ type: 'redis', redis: useRedis(), namespace: 'directus:bus' });
-    }
-    else {
-        _cache.bus = createBus({ type: 'local' });
-    }
-    return _cache.bus;
+* Returns globally shared message bus. If Redis is available, will use a redis-driven pub/sub bus.
+* Otherwise will default to a local-only bus.
+*/
+const useBus = () => {
+	if (_cache.bus) {
+		return _cache.bus;
+	}
+	if (redisConfigAvailable()) {
+		const env = useEnv();
+		_cache.bus = createBus({
+			type: "redis",
+			redis: useRedis(),
+			namespace: env["REDIS_BUS_NAMESPACE"] ?? "directus:bus"
+		});
+	} else {
+		_cache.bus = createBus({ type: "local" });
+	}
+	return _cache.bus;
 };
+
+//#endregion
+export { _cache, useBus };

package/dist/cache.js

@@ -1,15 +1,19 @@
-import { createRequire } from 'node:module';
-import { useEnv } from '@directus/env';
-import Keyv, {} from 'keyv';
-import { useBus } from './bus/index.js';
-import { useLogger } from './logger/index.js';
-import { clearCache as clearPermissionCache } from './permissions/cache.js';
-import { redisConfigAvailable } from './redis/index.js';
-import { compress, decompress } from './utils/compress.js';
-import { freezeSchema, unfreezeSchema } from './utils/freeze-schema.js';
-import { getConfigFromEnv } from './utils/get-config-from-env.js';
-import { getMilliseconds } from './utils/get-milliseconds.js';
-import { validateEnv } from './utils/validate-env.js';
+import { getConfigFromEnv } from "./utils/get-config-from-env.js";
+import { redisConfigAvailable } from "./redis/utils/redis-config-available.js";
+import "./redis/index.js";
+import { useBus } from "./bus/lib/use-bus.js";
+import "./bus/index.js";
+import { useLogger } from "./logger/index.js";
+import { getMilliseconds } from "./utils/get-milliseconds.js";
+import { clearCache } from "./permissions/cache.js";
+import { compress, decompress } from "./utils/compress.js";
+import { freezeSchema, unfreezeSchema } from "./utils/freeze-schema.js";
+import { validateEnv } from "./utils/validate-env.js";
+import { createRequire } from "node:module";
+import { useEnv } from "@directus/env";
+import Keyv from "keyv";
+
+//#region src/cache.ts
 const logger = useLogger();
 const env = useEnv();
 const require = createRequire(import.meta.url);
@@ -22,132 +26,140 @@ let localSchemaCache = null;
 let memorySchemaCache = null;
 const messenger = useBus();
 if (redisConfigAvailable() && !messengerSubscribed) {
-    messengerSubscribed = true;
-    messenger.subscribe('schemaChanged', async (opts) => {
-        if (env['CACHE_STORE'] === 'memory' && env['CACHE_AUTO_PURGE'] && cache && opts?.['autoPurgeCache'] !== false) {
-            await cache.clear();
-        }
-        await localSchemaCache?.clear();
-        memorySchemaCache = null;
-    });
+	messengerSubscribed = true;
+	messenger.subscribe("schemaChanged", async (opts) => {
+		if (env["CACHE_STORE"] === "memory" && env["CACHE_AUTO_PURGE"] && cache && opts?.["autoPurgeCache"] !== false) {
+			await cache.clear();
+		}
+		await localSchemaCache?.clear();
+		memorySchemaCache = null;
+	});
 }
-export function getCache() {
-    if (env['CACHE_ENABLED'] === true && cache === null) {
-        validateEnv(['CACHE_NAMESPACE', 'CACHE_TTL', 'CACHE_STORE']);
-        cache = getKeyvInstance(env['CACHE_STORE'], getMilliseconds(env['CACHE_TTL']));
-        cache.on('error', (err) => logger.warn(err, `[cache] ${err}`));
-    }
-    if (systemCache === null) {
-        systemCache = getKeyvInstance(env['CACHE_STORE'], getMilliseconds(env['CACHE_SYSTEM_TTL']), '_system');
-        systemCache.on('error', (err) => logger.warn(err, `[system-cache] ${err}`));
-    }
-    if (deploymentCache === null) {
-        const ttl = getMilliseconds(env['CACHE_DEPLOYMENT_TTL']) || 5000; // Default 5s
-        deploymentCache = getKeyvInstance(env['CACHE_STORE'], ttl, '_deployment');
-        deploymentCache.on('error', (err) => logger.warn(err, `[deployment-cache] ${err}`));
-    }
-    if (localSchemaCache === null) {
-        localSchemaCache = getKeyvInstance('memory', getMilliseconds(env['CACHE_SYSTEM_TTL']), '_schema');
-        localSchemaCache.on('error', (err) => logger.warn(err, `[schema-cache] ${err}`));
-    }
-    if (lockCache === null) {
-        lockCache = getKeyvInstance(env['CACHE_STORE'], undefined, '_lock');
-        lockCache.on('error', (err) => logger.warn(err, `[lock-cache] ${err}`));
-    }
-    return { cache, systemCache, deploymentCache, localSchemaCache, lockCache };
+function getCache() {
+	if (env["CACHE_ENABLED"] === true && cache === null) {
+		validateEnv([
+			"CACHE_NAMESPACE",
+			"CACHE_TTL",
+			"CACHE_STORE"
+		]);
+		cache = getKeyvInstance(env["CACHE_STORE"], getMilliseconds(env["CACHE_TTL"]));
+		cache.on("error", (err) => logger.warn(err, `[cache] ${err}`));
+	}
+	if (systemCache === null) {
+		systemCache = getKeyvInstance(env["CACHE_STORE"], getMilliseconds(env["CACHE_SYSTEM_TTL"]), "_system");
+		systemCache.on("error", (err) => logger.warn(err, `[system-cache] ${err}`));
+	}
+	if (deploymentCache === null) {
+		const ttl = getMilliseconds(env["CACHE_DEPLOYMENT_TTL"]) || 5e3;
+		deploymentCache = getKeyvInstance(env["CACHE_STORE"], ttl, "_deployment");
+		deploymentCache.on("error", (err) => logger.warn(err, `[deployment-cache] ${err}`));
+	}
+	if (localSchemaCache === null) {
+		localSchemaCache = getKeyvInstance("memory", getMilliseconds(env["CACHE_SYSTEM_TTL"]), "_schema");
+		localSchemaCache.on("error", (err) => logger.warn(err, `[schema-cache] ${err}`));
+	}
+	if (lockCache === null) {
+		lockCache = getKeyvInstance(env["CACHE_STORE"], undefined, "_lock");
+		lockCache.on("error", (err) => logger.warn(err, `[lock-cache] ${err}`));
+	}
+	return {
+		cache,
+		systemCache,
+		deploymentCache,
+		localSchemaCache,
+		lockCache
+	};
 }
-export async function flushCaches(forced) {
-    const { cache } = getCache();
-    await clearSystemCache({ forced });
-    await cache?.clear();
+async function flushCaches(forced) {
+	const { cache: cache$1 } = getCache();
+	await clearSystemCache({ forced });
+	await cache$1?.clear();
 }
-export async function clearSystemCache(opts) {
-    const { systemCache, localSchemaCache, lockCache } = getCache();
-    // Flush system cache when forced or when system cache lock not set
-    if (opts?.forced || !(await lockCache.get('system-cache-lock'))) {
-        await lockCache.set('system-cache-lock', true, 10000);
-        await systemCache.clear();
-        await lockCache.delete('system-cache-lock');
-    }
-    await localSchemaCache.clear();
-    memorySchemaCache = null;
-    // Since a lot of cached permission function rely on the schema it needs to be cleared as well
-    await clearPermissionCache();
-    messenger.publish('schemaChanged', { autoPurgeCache: opts?.autoPurgeCache });
+async function clearSystemCache(opts) {
+	const { systemCache: systemCache$1, localSchemaCache: localSchemaCache$1, lockCache: lockCache$1 } = getCache();
+	if (opts?.forced || !await lockCache$1.get("system-cache-lock")) {
+		await lockCache$1.set("system-cache-lock", true, 1e4);
+		await systemCache$1.clear();
+		await lockCache$1.delete("system-cache-lock");
+	}
+	await localSchemaCache$1.clear();
+	memorySchemaCache = null;
+	await clearCache();
+	messenger.publish("schemaChanged", { autoPurgeCache: opts?.autoPurgeCache });
 }
-export async function setSystemCache(key, value, ttl) {
-    const { systemCache, lockCache } = getCache();
-    if (!(await lockCache.get('system-cache-lock'))) {
-        await setCacheValue(systemCache, key, value, ttl);
-    }
+async function setSystemCache(key, value, ttl) {
+	const { systemCache: systemCache$1, lockCache: lockCache$1 } = getCache();
+	if (!await lockCache$1.get("system-cache-lock")) {
+		await setCacheValue(systemCache$1, key, value, ttl);
+	}
 }
-export async function getSystemCache(key) {
-    const { systemCache } = getCache();
-    return await getCacheValue(systemCache, key);
+async function getSystemCache(key) {
+	const { systemCache: systemCache$1 } = getCache();
+	return await getCacheValue(systemCache$1, key);
 }
-export function setMemorySchemaCache(schema) {
-    if (Object.isFrozen(schema)) {
-        memorySchemaCache = schema;
-    }
-    else {
-        memorySchemaCache = freezeSchema(schema);
-    }
+function setMemorySchemaCache(schema) {
+	if (Object.isFrozen(schema)) {
+		memorySchemaCache = schema;
+	} else {
+		memorySchemaCache = freezeSchema(schema);
+	}
 }
-export function getMemorySchemaCache() {
-    if (env['CACHE_SCHEMA_FREEZE_ENABLED']) {
-        return memorySchemaCache ?? undefined;
-    }
-    else if (memorySchemaCache) {
-        return unfreezeSchema(memorySchemaCache);
-    }
-    return undefined;
+function getMemorySchemaCache() {
+	if (env["CACHE_SCHEMA_FREEZE_ENABLED"]) {
+		return memorySchemaCache ?? undefined;
+	} else if (memorySchemaCache) {
+		return unfreezeSchema(memorySchemaCache);
+	}
+	return undefined;
 }
-export async function setCacheValue(cache, key, value, ttl) {
-    const compressed = await compress(value);
-    await cache.set(key, compressed, ttl);
+async function setCacheValue(cache$1, key, value, ttl) {
+	const compressed = await compress(value);
+	await cache$1.set(key, compressed, ttl);
 }
-export async function getCacheValue(cache, key) {
-    const value = await cache.get(key);
-    if (!value)
-        return undefined;
-    const decompressed = await decompress(value);
-    return decompressed;
+async function getCacheValue(cache$1, key) {
+	const value = await cache$1.get(key);
+	if (!value) return undefined;
+	const decompressed = await decompress(value);
+	return decompressed;
 }
 /**
- * Store a value in cache with its expiration timestamp for TTL tracking
- */
-export async function setCacheValueWithExpiry(cache, key, value, ttl) {
-    await setCacheValue(cache, key, value, ttl);
-    await setCacheValue(cache, `${key}__expires_at`, { exp: Date.now() + ttl }, ttl);
+* Store a value in cache with its expiration timestamp for TTL tracking
+*/
+async function setCacheValueWithExpiry(cache$1, key, value, ttl) {
+	await setCacheValue(cache$1, key, value, ttl);
+	await setCacheValue(cache$1, `${key}__expires_at`, { exp: Date.now() + ttl }, ttl);
 }
 /**
- * Get a cached value along with its remaining TTL
- */
-export async function getCacheValueWithTTL(cache, key) {
-    const value = await getCacheValue(cache, key);
-    if (!value)
-        return undefined;
-    const expiryData = await getCacheValue(cache, `${key}__expires_at`);
-    const remainingTTL = expiryData?.exp ? Math.max(0, expiryData.exp - Date.now()) : 0;
-    return { data: value, remainingTTL };
+* Get a cached value along with its remaining TTL
+*/
+async function getCacheValueWithTTL(cache$1, key) {
+	const value = await getCacheValue(cache$1, key);
+	if (!value) return undefined;
+	const expiryData = await getCacheValue(cache$1, `${key}__expires_at`);
+	const remainingTTL = expiryData?.exp ? Math.max(0, expiryData.exp - Date.now()) : 0;
+	return {
+		data: value,
+		remainingTTL
+	};
 }
 function getKeyvInstance(store, ttl, namespaceSuffix) {
-    switch (store) {
-        case 'redis':
-            return new Keyv(getConfig('redis', ttl, namespaceSuffix));
-        case 'memory':
-        default:
-            return new Keyv(getConfig('memory', ttl, namespaceSuffix));
-    }
+	switch (store) {
+		case "redis": return new Keyv(getConfig("redis", ttl, namespaceSuffix));
+		case "memory":
+		default: return new Keyv(getConfig("memory", ttl, namespaceSuffix));
+	}
 }
-function getConfig(store = 'memory', ttl, namespaceSuffix = '') {
-    const config = {
-        namespace: `${env['CACHE_NAMESPACE']}${namespaceSuffix}`,
-        ...(ttl && { ttl }),
-    };
-    if (store === 'redis') {
-        const { default: KeyvRedis } = require('@keyv/redis');
-        config.store = new KeyvRedis(env['REDIS'] || getConfigFromEnv('REDIS'), { useRedisSets: false });
-    }
-    return config;
+function getConfig(store = "memory", ttl, namespaceSuffix = "") {
+	const config = {
+		namespace: `${env["CACHE_NAMESPACE"]}${namespaceSuffix}`,
+		...ttl && { ttl }
+	};
+	if (store === "redis") {
+		const { default: KeyvRedis } = require("@keyv/redis");
+		config.store = new KeyvRedis(env["REDIS"] || getConfigFromEnv("REDIS"), { useRedisSets: false });
+	}
+	return config;
 }
+
+//#endregion
+export { clearSystemCache, flushCaches, getCache, getCacheValue, getCacheValueWithTTL, getMemorySchemaCache, getSystemCache, setCacheValue, setCacheValueWithExpiry, setMemorySchemaCache, setSystemCache };

package/dist/cli/commands/bootstrap/index.js

@@ -1,62 +1,64 @@
-import { useEnv } from '@directus/env';
-import { email } from 'zod';
-import getDatabase, { hasDatabaseConnection, isInstalled, validateDatabaseConnection, } from '../../../database/index.js';
-import runMigrations from '../../../database/migrations/run.js';
-import installDatabase from '../../../database/seeds/run.js';
-import { useLogger } from '../../../logger/index.js';
-import { SettingsService } from '../../../services/settings.js';
-import { createAdmin } from '../../../utils/create-admin.js';
-import { getSchema } from '../../../utils/get-schema.js';
-export default async function bootstrap({ skipAdminInit }) {
-    const logger = useLogger();
-    logger.info('Initializing bootstrap...');
-    const env = useEnv();
-    const database = getDatabase();
-    await waitForDatabase(database);
-    if ((await isInstalled()) === false) {
-        logger.info('Installing Directus system tables...');
-        await installDatabase(database);
-        logger.info('Running migrations...');
-        await runMigrations(database, 'latest');
-        const schema = await getSchema();
-        if (skipAdminInit == null) {
-            await createAdmin(schema);
-        }
-        else {
-            logger.info('Skipping creation of default Admin user and role...');
-        }
-        const settingsService = new SettingsService({ schema });
-        if (env['PROJECT_NAME'] && typeof env['PROJECT_NAME'] === 'string' && env['PROJECT_NAME'].length > 0) {
-            await settingsService.upsertSingleton({ project_name: env['PROJECT_NAME'] });
-        }
-        if (email().safeParse(env['PROJECT_OWNER']).success) {
-            await settingsService.setOwner({
-                project_owner: env['PROJECT_OWNER'],
-                org_name: null,
-                project_usage: null,
-                product_updates: false,
-            });
-        }
-    }
-    else {
-        logger.info('Database already initialized, skipping install');
-        logger.info('Running migrations...');
-        await runMigrations(database, 'latest');
-    }
-    await database.destroy();
-    logger.info('Done');
-    process.exit(0);
+import { useLogger } from "../../../logger/index.js";
+import database_default, { hasDatabaseConnection, isInstalled, validateDatabaseConnection } from "../../../database/index.js";
+import { getSchema } from "../../../utils/get-schema.js";
+import { SettingsService } from "../../../services/settings.js";
+import { createAdmin } from "../../../utils/create-admin.js";
+import run from "../../../database/migrations/run.js";
+import runSeed from "../../../database/seeds/run.js";
+import { useEnv } from "@directus/env";
+import { email } from "zod";
+
+//#region src/cli/commands/bootstrap/index.ts
+async function bootstrap({ skipAdminInit }) {
+	const logger = useLogger();
+	logger.info("Initializing bootstrap...");
+	const env = useEnv();
+	const database = database_default();
+	await waitForDatabase(database);
+	if (await isInstalled() === false) {
+		logger.info("Installing Directus system tables...");
+		await runSeed(database);
+		logger.info("Running migrations...");
+		await run(database, "latest");
+		const schema = await getSchema();
+		if (skipAdminInit == null) {
+			await createAdmin(schema);
+		} else {
+			logger.info("Skipping creation of default Admin user and role...");
+		}
+		const settingsService = new SettingsService({ schema });
+		if (env["PROJECT_NAME"] && typeof env["PROJECT_NAME"] === "string" && env["PROJECT_NAME"].length > 0) {
+			await settingsService.upsertSingleton({ project_name: env["PROJECT_NAME"] });
+		}
+		if (email().safeParse(env["PROJECT_OWNER"]).success) {
+			await settingsService.setOwner({
+				project_owner: env["PROJECT_OWNER"],
+				org_name: null,
+				project_usage: null,
+				product_updates: false
+			});
+		}
+	} else {
+		logger.info("Database already initialized, skipping install");
+		logger.info("Running migrations...");
+		await run(database, "latest");
+	}
+	await database.destroy();
+	logger.info("Done");
+	process.exit(0);
 }
 async function waitForDatabase(database) {
-    const tries = 5;
-    const secondsBetweenTries = 5;
-    for (let i = 0; i < tries; i++) {
-        if (await hasDatabaseConnection(database)) {
-            return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, secondsBetweenTries * 1000));
-    }
-    // This will throw and exit the process if the database is not available
-    await validateDatabaseConnection(database);
-    return database;
+	const tries = 5;
+	const secondsBetweenTries = 5;
+	for (let i = 0; i < tries; i++) {
+		if (await hasDatabaseConnection(database)) {
+			return true;
+		}
+		await new Promise((resolve) => setTimeout(resolve, secondsBetweenTries * 1e3));
+	}
+	await validateDatabaseConnection(database);
+	return database;
 }
+
+//#endregion
+export { bootstrap as default };

package/dist/cli/commands/cache/clear.js

@@ -0,0 +1,33 @@
+import { useLogger } from "../../../logger/index.js";
+import { clearSystemCache, getCache } from "../../../cache.js";
+import { useEnv } from "@directus/env";
+
+//#region src/cli/commands/cache/clear.ts
+async function cacheClear({ system, data }) {
+	const env = useEnv();
+	const logger = useLogger();
+	if (env["CACHE_STORE"] !== "redis") {
+		process.stdout.write("CACHE_STORE is not set to \"redis\". In-memory caches are local to each running process and cannot be cleared externally.\n");
+		process.exit(0);
+	} else {
+		const clearAll = !system && !data;
+		try {
+			if (clearAll || system) {
+				await clearSystemCache({ forced: true });
+			}
+			if (clearAll || data) {
+				const { cache } = getCache();
+				await cache?.clear();
+			}
+			const target = clearAll ? "all caches" : [system && "system cache", data && "data cache"].filter(Boolean).join(" and ");
+			process.stdout.write(`Cleared ${target} successfully\n`);
+			process.exit(0);
+		} catch (err) {
+			logger.error(err);
+			process.exit(1);
+		}
+	}
+}
+
+//#endregion
+export { cacheClear as default };