@nocobase/cli 2.1.0-beta.9 → 2.2.0-alpha.1

package/dist/lib/cli-locale.js

@@ -0,0 +1,141 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveCliHomeDir } from './cli-home.js';
+export const SUPPORTED_CLI_LOCALES = ['en-US', 'zh-CN'];
+export const CLI_LOCALE_FLAG_OPTIONS = [...SUPPORTED_CLI_LOCALES];
+export const CLI_LOCALE_FLAG_DESCRIPTION = 'Language for CLI prompts and the local setup UI.';
+const DEFAULT_CLI_LOCALE = 'en-US';
+const localeCache = {};
+export function normalizeCliLocale(value) {
+    const raw = String(value ?? '').trim();
+    if (!raw) {
+        return undefined;
+    }
+    const normalized = raw.replace(/\..*$/, '').replace(/_/g, '-').toLowerCase();
+    if (normalized === 'zh' || normalized.startsWith('zh-')) {
+        return 'zh-CN';
+    }
+    if (normalized === 'en' || normalized.startsWith('en-')) {
+        return 'en-US';
+    }
+    return undefined;
+}
+function readConfiguredCliLocale() {
+    try {
+        const configPath = path.join(resolveCliHomeDir(), 'config.json');
+        const content = readFileSync(configPath, 'utf8');
+        const parsed = JSON.parse(content);
+        return normalizeCliLocale(parsed.settings?.locale === undefined ? undefined : String(parsed.settings.locale));
+    }
+    catch {
+        return undefined;
+    }
+}
+function loadLocaleMessages(locale) {
+    if (localeCache[locale]) {
+        return localeCache[locale];
+    }
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const fallbackPath = path.resolve(moduleDir, '..', 'locale', `${locale}.json`);
+    const fileUrl = new URL(`../locale/${locale}.json`, import.meta.url);
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(fileUrl, 'utf8'));
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        parsed = JSON.parse(readFileSync(fallbackPath, 'utf8'));
+    }
+    localeCache[locale] = parsed;
+    return parsed;
+}
+function getPathValue(input, path) {
+    let current = input;
+    for (const part of path.split('.')) {
+        if (!current || typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, part)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function interpolateTemplate(template, values) {
+    return template.replace(/{{\s*([\w.]+)\s*}}/g, (_match, key) => {
+        const value = getPathValue(values, key);
+        return value === undefined || value === null ? '' : String(value);
+    });
+}
+export function detectCliLocale(configuredLocale) {
+    const resolvedConfiguredLocale = configuredLocale ?? readConfiguredCliLocale();
+    const candidates = [
+        process.env.NB_LOCALE,
+        resolvedConfiguredLocale,
+        process.env.LC_ALL,
+        process.env.LC_MESSAGES,
+        process.env.LANG,
+        Intl.DateTimeFormat().resolvedOptions().locale,
+    ];
+    for (const candidate of candidates) {
+        const locale = normalizeCliLocale(candidate);
+        if (locale) {
+            return locale;
+        }
+    }
+    return DEFAULT_CLI_LOCALE;
+}
+export function resolveCliLocale(preferred, options) {
+    return normalizeCliLocale(preferred) ?? detectCliLocale(options?.configuredLocale);
+}
+export function applyCliLocale(preferred) {
+    const locale = resolveCliLocale(preferred);
+    process.env.NB_LOCALE = locale;
+    return locale;
+}
+export function createCliTranslate(preferred) {
+    const locale = resolveCliLocale(preferred);
+    return (key, values, fallback) => {
+        const messages = loadLocaleMessages(locale);
+        const template = getPathValue(messages, key);
+        if (typeof template !== 'string') {
+            return interpolateTemplate(fallback ?? key, values);
+        }
+        return interpolateTemplate(template, values);
+    };
+}
+export function translateCli(key, values, options) {
+    return createCliTranslate(options?.locale)(key, values, options?.fallback);
+}
+export function localeText(key, values, fallback) {
+    return {
+        key,
+        ...(values ? { values } : {}),
+        ...(fallback ? { fallback } : {}),
+    };
+}
+export function isLocalizedTextDef(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.key === 'string');
+}
+export function resolveLocalizedText(text, options) {
+    if (text === undefined) {
+        return options?.fallback ?? '';
+    }
+    if (typeof text === 'string') {
+        return text;
+    }
+    return translateCli(text.key, text.values, {
+        locale: options?.locale,
+        fallback: text.fallback ?? options?.fallback,
+    });
+}

package/dist/lib/command-discovery.js

@@ -0,0 +1,39 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Recursively collect command module paths under `commandsRoot` (e.g. `dist/commands` → `.js`, `src/commands` → `.ts`).
+ */
+export async function collectCommandModulePaths(commandsRoot, extension) {
+    const entries = await readdir(commandsRoot, { withFileTypes: true });
+    const files = [];
+    for (const ent of entries) {
+        const full = join(commandsRoot, ent.name);
+        if (ent.isDirectory()) {
+            files.push(...(await collectCommandModulePaths(full, extension)));
+        }
+        else if (ent.isFile() && ent.name.endsWith(extension)) {
+            files.push(full);
+        }
+    }
+    return files.sort();
+}
+/**
+ * Map a path relative to `commands/` with `.js` / `.ts` to an oclif explicit-registry key.
+ * `api/resource/foo.js` → `api:resource:foo`; trailing `index` maps to the parent command.
+ */
+export function commandRelativePathToRegistryKey(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/').replace(/\.(js|ts)$/i, '');
+    const segments = normalized.split('/').filter(Boolean);
+    if (segments.at(-1) === 'index') {
+        segments.pop();
+    }
+    return segments.join(':');
+}

package/dist/lib/command-log.js

@@ -0,0 +1,284 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { resolveCliHomeDir } from './cli-home.js';
+import { DEFAULT_LOG_ENABLED, DEFAULT_LOG_RETENTION_DAYS, getCliConfigValue } from './cli-config.js';
+const ACTIVE_LOG_FILE_ENV = 'NB_CLI_ACTIVE_LOG_FILE';
+const ACTIVE_META_FILE_ENV = 'NB_CLI_ACTIVE_META_FILE';
+const LOG_DIR_ENV = 'NB_CLI_LOG_DIR';
+const LOG_DISABLED_ENV = 'NB_CLI_LOG_DISABLED';
+const ANSI_ESCAPE_PATTERN = new RegExp(String.raw `\u001B\[[0-?]*[ -/]*[@-~]`, 'g');
+const CLEANUP_STATE_FILE = '.cleanup-state.json';
+const CLEANUP_INTERVAL_MS = 12 * 60 * 60 * 1000;
+function isTruthyEnvFlag(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+function formatDateParts(date) {
+    const year = date.getFullYear();
+    const month = pad(date.getMonth() + 1);
+    const day = pad(date.getDate());
+    const hour = pad(date.getHours());
+    const minute = pad(date.getMinutes());
+    const second = pad(date.getSeconds());
+    return {
+        dayKey: `${year}-${month}-${day}`,
+        timestampKey: `${year}${month}${day}-${hour}${minute}${second}`,
+    };
+}
+function sanitizeFileNameSegment(value) {
+    const normalized = value
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    return normalized || 'command';
+}
+function resolveSessionDirName(sessionId) {
+    const trimmed = String(sessionId ?? '').trim();
+    if (!trimmed) {
+        return 'no-session';
+    }
+    return sanitizeFileNameSegment(trimmed);
+}
+export function stripAnsi(value) {
+    return value.replace(ANSI_ESCAPE_PATTERN, '');
+}
+export function shouldEnableCommandLog(env = process.env) {
+    return !isTruthyEnvFlag(env[LOG_DISABLED_ENV]);
+}
+export function resolveCommandLogDir(env = process.env) {
+    if (!shouldEnableCommandLog(env)) {
+        return undefined;
+    }
+    const configured = String(env[LOG_DIR_ENV] ?? '').trim();
+    if (configured) {
+        return path.resolve(configured);
+    }
+    return path.join(resolveCliHomeDir(), 'logs');
+}
+export function getActiveCommandLogFile(env = process.env) {
+    const value = String(env[ACTIVE_LOG_FILE_ENV] ?? '').trim();
+    return value || undefined;
+}
+function readActiveCommandMetaFile(env = process.env) {
+    const value = String(env[ACTIVE_META_FILE_ENV] ?? '').trim();
+    return value || undefined;
+}
+export function hasActiveCommandLog(env = process.env) {
+    return Boolean(getActiveCommandLogFile(env));
+}
+export function sanitizeArgv(argv) {
+    const sensitiveFlags = new Set(['--token', '--access-token', '--password', '--secret']);
+    const sanitized = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (sensitiveFlags.has(token)) {
+            sanitized.push(token);
+            if (index + 1 < argv.length) {
+                sanitized.push('***');
+                index += 1;
+            }
+            continue;
+        }
+        const matched = token.match(/^(--(?:token|access-token|password|secret))=(.*)$/);
+        if (matched) {
+            sanitized.push(`${matched[1]}=***`);
+            continue;
+        }
+        sanitized.push(token);
+    }
+    return sanitized;
+}
+export function getCommandLogCommandId(argv) {
+    const positional = argv.filter((token) => token && !token.startsWith('-'));
+    if (positional.length === 0) {
+        return 'command';
+    }
+    const commandPath = positional[0] === 'api' ? positional.slice(0, 3) : positional.slice(0, 2);
+    return sanitizeFileNameSegment(commandPath.join('-'));
+}
+function parseDateDirName(name) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(name)) {
+        return undefined;
+    }
+    const parsed = new Date(`${name}T00:00:00.000Z`);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+async function readCleanupState(filePath) {
+    try {
+        return JSON.parse(await fsp.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+async function writeCleanupState(filePath, state) {
+    await fsp.writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+async function resolveCommandLogRetentionDays() {
+    const configured = await getCliConfigValue('log.retention-days').catch(() => String(DEFAULT_LOG_RETENTION_DAYS));
+    const parsed = Number.parseInt(String(configured).trim(), 10);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        return DEFAULT_LOG_RETENTION_DAYS;
+    }
+    return parsed;
+}
+async function resolveCommandLogEnabled() {
+    const configured = await getCliConfigValue('log.enabled').catch(() => String(DEFAULT_LOG_ENABLED));
+    const normalized = String(configured).trim().toLowerCase();
+    if (normalized === 'false') {
+        return false;
+    }
+    if (normalized === 'true') {
+        return true;
+    }
+    return DEFAULT_LOG_ENABLED;
+}
+async function cleanupCommandLogs(rootDir, retentionDays, now = new Date()) {
+    if (retentionDays === 0) {
+        return;
+    }
+    const entries = await fsp.readdir(rootDir, { withFileTypes: true }).catch(() => []);
+    const cutoff = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+    cutoff.setUTCDate(cutoff.getUTCDate() - retentionDays + 1);
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const dirDate = parseDateDirName(entry.name);
+        if (!dirDate || dirDate >= cutoff) {
+            continue;
+        }
+        await fsp.rm(path.join(rootDir, entry.name), { recursive: true, force: true });
+    }
+}
+async function maybeCleanupCommandLogs(rootDir, env = process.env) {
+    await fsp.mkdir(rootDir, { recursive: true });
+    const stateFile = path.join(rootDir, CLEANUP_STATE_FILE);
+    const state = await readCleanupState(stateFile);
+    const lastCleanupAt = Date.parse(String(state.lastCleanupAt ?? ''));
+    if (!Number.isNaN(lastCleanupAt) && Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) {
+        return;
+    }
+    const retentionDays = await resolveCommandLogRetentionDays();
+    await cleanupCommandLogs(rootDir, retentionDays);
+    await writeCleanupState(stateFile, { lastCleanupAt: new Date().toISOString() });
+}
+async function writeMetaFile(filePath, meta) {
+    await fsp.mkdir(path.dirname(filePath), { recursive: true });
+    await fsp.writeFile(filePath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+}
+function writeMetaFileSync(filePath, meta) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+}
+export async function initCommandLogSession(options) {
+    const env = options.env ?? process.env;
+    if (!shouldEnableCommandLog(env)) {
+        return undefined;
+    }
+    const enabled = await resolveCommandLogEnabled().catch(() => DEFAULT_LOG_ENABLED);
+    if (!enabled) {
+        return undefined;
+    }
+    const rootDir = resolveCommandLogDir(env);
+    if (!rootDir) {
+        return undefined;
+    }
+    await maybeCleanupCommandLogs(rootDir, env).catch(() => undefined);
+    const startedAt = options.startedAt ?? new Date();
+    const { dayKey, timestampKey } = formatDateParts(startedAt);
+    const commandId = getCommandLogCommandId(options.argv);
+    const fileStem = `${timestampKey}-${commandId}-${options.pid ?? process.pid}`;
+    const sessionDirName = resolveSessionDirName(options.sessionId);
+    const logDir = path.join(rootDir, dayKey, sessionDirName);
+    const logFile = path.join(logDir, `${fileStem}.log`);
+    const metaFile = path.join(logDir, `${fileStem}.meta.json`);
+    const meta = {
+        command: commandId,
+        argv: sanitizeArgv(options.argv),
+        cwd: options.cwd,
+        pid: options.pid ?? process.pid,
+        ppid: options.ppid ?? process.ppid,
+        sessionId: options.sessionId,
+        startedAt: startedAt.toISOString(),
+        logFile,
+        cliVersion: options.cliVersion,
+        nodeVersion: options.nodeVersion,
+        platform: options.platform,
+        interactive: options.interactive,
+        verbose: options.verbose,
+    };
+    await fsp.mkdir(logDir, { recursive: true });
+    await fsp.writeFile(logFile, '', 'utf8');
+    await writeMetaFile(metaFile, meta);
+    env[ACTIVE_LOG_FILE_ENV] = logFile;
+    env[ACTIVE_META_FILE_ENV] = metaFile;
+    return {
+        logFile,
+        metaFile,
+        meta,
+    };
+}
+export function finalizeCommandLogSessionSync(session, options = {}) {
+    if (!session) {
+        return;
+    }
+    const endedAt = options.endedAt ?? new Date();
+    const startedAtMs = Date.parse(session.meta.startedAt);
+    const nextMeta = {
+        ...session.meta,
+        endedAt: endedAt.toISOString(),
+        durationMs: Number.isNaN(startedAtMs) ? undefined : Math.max(0, endedAt.getTime() - startedAtMs),
+        exitCode: options.exitCode ?? session.meta.exitCode,
+        signal: options.signal ?? session.meta.signal,
+        errorMessage: options.errorMessage ?? session.meta.errorMessage,
+    };
+    writeMetaFileSync(session.metaFile, nextMeta);
+    session.meta = nextMeta;
+}
+export function appendCommandLogChunk(chunk, env = process.env) {
+    const logFile = getActiveCommandLogFile(env);
+    if (!logFile) {
+        return;
+    }
+    const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
+    if (!text) {
+        return;
+    }
+    fs.appendFileSync(logFile, stripAnsi(text), 'utf8');
+}
+export function installCommandLogWriteHooks(env = process.env) {
+    if (!hasActiveCommandLog(env)) {
+        return undefined;
+    }
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = ((chunk, encoding, callback) => {
+        appendCommandLogChunk(chunk, env);
+        return originalStdoutWrite(chunk, encoding, callback);
+    });
+    process.stderr.write = ((chunk, encoding, callback) => {
+        appendCommandLogChunk(chunk, env);
+        return originalStderrWrite(chunk, encoding, callback);
+    });
+    return () => {
+        process.stdout.write = originalStdoutWrite;
+        process.stderr.write = originalStderrWrite;
+    };
+}
+export function getActiveCommandMetaFile(env = process.env) {
+    return readActiveCommandMetaFile(env);
+}

package/dist/lib/db-connection-check.js

@@ -0,0 +1,219 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { translateCli } from "./cli-locale.js";
+import { validateTcpPort } from "./prompt-validators.js";
+const DB_CONNECTION_TIMEOUT_MS = 5_000;
+const externalDbValidationCache = new Map();
+const mysqlLowerCaseTableNamesCache = new Map();
+function trimPromptValue(value) {
+    return String(value ?? '').trim();
+}
+export function readExternalDbConnectionConfig(values) {
+    const builtinDb = values.builtinDb === undefined ? true : Boolean(values.builtinDb);
+    if (builtinDb) {
+        return undefined;
+    }
+    const dialect = trimPromptValue(values.dbDialect || 'postgres');
+    if (dialect !== 'postgres' && dialect !== 'kingbase' && dialect !== 'mysql' && dialect !== 'mariadb') {
+        return undefined;
+    }
+    const host = trimPromptValue(values.dbHost);
+    const portText = trimPromptValue(values.dbPort);
+    const database = trimPromptValue(values.dbDatabase);
+    const user = trimPromptValue(values.dbUser);
+    const password = String(values.dbPassword ?? '');
+    if (!host || !portText || !database || !user || !password) {
+        return undefined;
+    }
+    if (validateTcpPort(portText)) {
+        return undefined;
+    }
+    return {
+        dialect,
+        host,
+        port: Number.parseInt(portText, 10),
+        database,
+        user,
+        password,
+    };
+}
+export function formatDbCheckAddress(config) {
+    return `${config.host}:${config.port}/${config.database}`;
+}
+function buildValidationCacheKey(config) {
+    return JSON.stringify(config);
+}
+function formatDbConnectionError(config, error) {
+    const maybeError = error;
+    const code = String(maybeError?.code ?? '').trim().toUpperCase();
+    const errno = typeof maybeError?.errno === 'number' ? maybeError.errno : undefined;
+    const rawMessage = String(maybeError?.message || maybeError?.sqlMessage || error || '').trim();
+    if (code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'EHOSTUNREACH' || code === 'ECONNRESET') {
+        return translateCli('validators.dbConnection.unreachable', {
+            host: config.host,
+            port: config.port,
+            details: rawMessage,
+        });
+    }
+    if (code === 'ETIMEDOUT') {
+        return translateCli('validators.dbConnection.timeout', {
+            host: config.host,
+            port: config.port,
+            seconds: Math.ceil(DB_CONNECTION_TIMEOUT_MS / 1000),
+        });
+    }
+    if (code === '28P01' || code === '28000' || code === 'ER_ACCESS_DENIED_ERROR' || errno === 1045) {
+        return translateCli('validators.dbConnection.authenticationFailed', {
+            user: config.user,
+            database: config.database,
+        });
+    }
+    if (code === '3D000' || code === 'ER_BAD_DB_ERROR' || errno === 1049) {
+        return translateCli('validators.dbConnection.databaseNotFound', {
+            database: config.database,
+        });
+    }
+    return translateCli('validators.dbConnection.connectionFailed', {
+        details: rawMessage || code || String(error),
+    });
+}
+async function checkPostgresFamilyConnection(config) {
+    const { default: pg } = await import('pg');
+    const client = new pg.Client({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        connectionTimeoutMillis: DB_CONNECTION_TIMEOUT_MS,
+    });
+    try {
+        await client.connect();
+        await client.query('SELECT 1');
+    }
+    finally {
+        await Promise.resolve(client.end()).catch(() => undefined);
+    }
+}
+async function checkMysqlFamilyConnection(config) {
+    const { default: mysql } = await import('mysql2/promise');
+    const connection = await mysql.createConnection({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        connectTimeout: DB_CONNECTION_TIMEOUT_MS,
+    });
+    try {
+        await connection.query('SELECT 1');
+    }
+    finally {
+        await Promise.resolve(connection.end()).catch(() => undefined);
+    }
+}
+async function readMysqlFamilyLowerCaseTableNames(config) {
+    const { default: mysql } = await import('mysql2/promise');
+    const connection = await mysql.createConnection({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        connectTimeout: DB_CONNECTION_TIMEOUT_MS,
+    });
+    try {
+        const [rows] = await connection.query(`SHOW VARIABLES LIKE 'lower_case_table_names'`);
+        if (!Array.isArray(rows)) {
+            return undefined;
+        }
+        for (const row of rows) {
+            if (!row || typeof row !== 'object') {
+                continue;
+            }
+            const value = String(row.Value ?? '').trim();
+            if (value === '0' || value === '1' || value === '2') {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    finally {
+        await Promise.resolve(connection.end()).catch(() => undefined);
+    }
+}
+async function performExternalDbConnectionCheck(config) {
+    try {
+        switch (config.dialect) {
+            case 'postgres':
+            case 'kingbase': {
+                await checkPostgresFamilyConnection(config);
+                return undefined;
+            }
+            case 'mysql':
+            case 'mariadb': {
+                await checkMysqlFamilyConnection(config);
+                return undefined;
+            }
+        }
+    }
+    catch (error) {
+        return formatDbConnectionError(config, error);
+    }
+}
+export async function checkExternalDbConnection(config) {
+    const cacheKey = buildValidationCacheKey(config);
+    const cached = externalDbValidationCache.get(cacheKey);
+    if (cached) {
+        return await cached;
+    }
+    const pending = performExternalDbConnectionCheck(config);
+    externalDbValidationCache.set(cacheKey, pending);
+    return await pending;
+}
+async function readMysqlLowerCaseTableNamesMode(config) {
+    if (config.dialect !== 'mysql' && config.dialect !== 'mariadb') {
+        return undefined;
+    }
+    const cacheKey = buildValidationCacheKey(config);
+    const cached = mysqlLowerCaseTableNamesCache.get(cacheKey);
+    if (cached) {
+        return await cached;
+    }
+    const pending = readMysqlFamilyLowerCaseTableNames(config);
+    mysqlLowerCaseTableNamesCache.set(cacheKey, pending);
+    return await pending;
+}
+export async function validateExternalDbConfig(values) {
+    const config = readExternalDbConnectionConfig(values);
+    if (!config) {
+        return undefined;
+    }
+    return await checkExternalDbConnection(config);
+}
+export async function validateMysqlLowerCaseTableNamesCompatibility(values) {
+    const config = readExternalDbConnectionConfig(values);
+    if (!config || (config.dialect !== 'mysql' && config.dialect !== 'mariadb')) {
+        return undefined;
+    }
+    try {
+        const mode = await readMysqlLowerCaseTableNamesMode(config);
+        if (mode === '1' && values.dbUnderscored !== true) {
+            return translateCli('validators.dbConnection.lowerCaseTableNamesRequiresUnderscored');
+        }
+        return undefined;
+    }
+    catch (error) {
+        return formatDbConnectionError(config, error);
+    }
+}
+export function clearExternalDbValidationCache() {
+    externalDbValidationCache.clear();
+    mysqlLowerCaseTableNamesCache.clear();
+}