@nocobase/cli 2.1.0-beta.35 → 2.1.0-beta.37

package/dist/lib/backup.js

@@ -0,0 +1,171 @@
+/**
+ * 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 { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getCurrentEnvName, getEnv, listEnvs } from './auth-store.js';
+import { updateEnvRuntime } from './bootstrap.js';
+import { resolveDefaultConfigScope } from './cli-home.js';
+import { commandOutput } from './run-npm.js';
+import { loadRuntimeSync } from './runtime-store.js';
+import { failTask, startTask, succeedTask } from './ui.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+const CLI_CONFIG_FILE = path.join(CLI_PACKAGE_ROOT, 'nocobase-ctl.config.json');
+const CLI_ENTRY_FILE = path.join(CLI_PACKAGE_ROOT, 'bin', 'run.js');
+export const BACKUP_POLL_INTERVAL_MS = 2_000;
+export const BACKUP_CREATE_TIMEOUT_MS = 600_000;
+export const BACKUP_RUNTIME_COMMANDS = {
+    create: 'backup create',
+    status: 'backup status',
+    download: 'backup download',
+    restoreUpload: 'backup restore-upload',
+};
+function hasRequiredBackupCommands(runtime, commandIds) {
+    if (!runtime) {
+        return false;
+    }
+    const available = new Set(runtime.commands.map((command) => command.commandId));
+    return commandIds.every((commandId) => available.has(commandId));
+}
+function formatMissingBackupRuntimeCommands(envName, commandIds) {
+    const missing = commandIds.map((commandId) => `nb api ${commandId}`).join(', ');
+    return [
+        `The selected env "${envName}" does not expose the backup API commands required by \`nb backup\`.`,
+        `Missing commands: ${missing}`,
+        'Enable or upgrade the backup/restore capability for that env, then try again.',
+    ].join('\n');
+}
+export function buildBackupEnvArgv(options) {
+    const argv = [];
+    if (options.explicitEnvSelection && options.requestedEnv) {
+        argv.push('--env', options.requestedEnv);
+    }
+    if (options.yes || options.explicitEnvSelection) {
+        argv.push('--yes');
+    }
+    return argv;
+}
+export async function resolveBackupTargetEnv(requestedEnv) {
+    const scope = resolveDefaultConfigScope();
+    const envName = requestedEnv?.trim() || (await getCurrentEnvName({ scope }));
+    const env = await getEnv(envName, { scope });
+    if (env) {
+        return { scope, envName, env };
+    }
+    const { envs } = await listEnvs({ scope });
+    const configuredEnvNames = Object.keys(envs);
+    if (!configuredEnvNames.length) {
+        throw new Error('No env is configured. Run `nb env add <name> --api-base-url <url>` first.');
+    }
+    if (requestedEnv?.trim()) {
+        throw new Error(`Env "${envName}" is not configured. Run \`nb env add ${envName} --api-base-url <url>\` first.`);
+    }
+    throw new Error([
+        `Current env "${envName}" is not configured.`,
+        'Switch to an existing env with `nb env use <name>`, or add one with `nb env add <name> --api-base-url <url>`.',
+    ].join('\n'));
+}
+export async function ensureBackupRuntimeCommands(params) {
+    const scope = resolveDefaultConfigScope();
+    const env = params.env ?? (await getEnv(params.envName, { scope }));
+    const currentRuntime = loadRuntimeSync(env?.runtime?.version, { scope });
+    if (hasRequiredBackupCommands(currentRuntime, params.commandIds)) {
+        return;
+    }
+    if (!params.quiet) {
+        startTask(`Refreshing env runtime for "${params.envName}" to load backup commands...`);
+    }
+    try {
+        const runtime = await updateEnvRuntime({
+            envName: params.envName,
+            scope,
+            configFile: CLI_CONFIG_FILE,
+            quiet: params.quiet,
+        });
+        if (!hasRequiredBackupCommands(runtime, params.commandIds)) {
+            throw new Error(formatMissingBackupRuntimeCommands(params.envName, params.commandIds));
+        }
+        if (!params.quiet) {
+            succeedTask(`Env runtime is ready for backup commands in "${params.envName}".`);
+        }
+    }
+    catch (error) {
+        if (!params.quiet) {
+            failTask(`Failed to refresh backup commands for "${params.envName}".`);
+        }
+        throw error;
+    }
+}
+export async function runBackupCliCommand(argv, options) {
+    return await commandOutput(process.execPath, [CLI_ENTRY_FILE, ...argv], {
+        errorName: options?.errorName ?? `nb ${argv.join(' ')}`,
+        env: {
+            NB_SKIP_STARTUP_UPDATE: '1',
+            // When the parent CLI already runs in tsx source mode, it sets
+            // `_NOCO_CLI_TSX_CHILD=1`. Clear it here so `bin/run.js` can re-exec
+            // itself with `--import tsx` again instead of trying to import `.ts`
+            // sources without the loader.
+            _NOCO_CLI_TSX_CHILD: '',
+        },
+    });
+}
+export async function runBackupCliJsonCommand(argv, options) {
+    const output = await runBackupCliCommand([...argv, '--json-output'], options);
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        throw new Error(`Unexpected JSON output from ${options?.errorName ?? `nb ${argv.join(' ')}`}: ${output || '(empty output)'}`);
+    }
+}
+export async function resolveBackupCreateOutputPath(output, remoteName) {
+    const requestedOutput = String(output ?? '').trim();
+    if (!requestedOutput) {
+        return path.resolve(process.cwd(), remoteName);
+    }
+    const resolvedOutput = path.resolve(process.cwd(), requestedOutput);
+    try {
+        const stats = await fs.stat(resolvedOutput);
+        if (stats.isDirectory()) {
+            return path.join(resolvedOutput, remoteName);
+        }
+    }
+    catch {
+        // Treat non-existing paths as an explicit target file path.
+    }
+    return resolvedOutput;
+}
+export async function resolveBackupRestoreFilePath(file) {
+    const resolvedFile = path.resolve(process.cwd(), file);
+    let stats;
+    try {
+        stats = await fs.stat(resolvedFile);
+    }
+    catch {
+        throw new Error(`Backup file not found: ${resolvedFile}`);
+    }
+    if (!stats.isFile()) {
+        throw new Error(`Backup restore input must be a file: ${resolvedFile}`);
+    }
+    return resolvedFile;
+}
+export function resolveBackupWaitApiBaseUrl(env) {
+    const baseUrl = String(env.baseUrl ?? '').trim();
+    if (baseUrl) {
+        return baseUrl.replace(/\/+$/, '');
+    }
+    const appPort = env.appPort === undefined || env.appPort === null
+        ? ''
+        : String(env.appPort).trim();
+    return appPort ? `http://127.0.0.1:${appPort}/api` : undefined;
+}
+export async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/lib/bootstrap.js

@@ -137,7 +137,7 @@ function getSwaggerUrl(baseUrl) {
 function getHealthCheckUrl(baseUrl) {
     return `${baseUrl.replace(/\/+$/, '')}/__health_check`;
 }
-async function waitForServiceReady(baseUrl, token, role) {
+async function waitForServiceReady(baseUrl, token, role, options) {
     const healthCheckUrl = getHealthCheckUrl(baseUrl);
     const startedAt = Date.now();
     let notified = false;
@@ -162,18 +162,22 @@ async function waitForServiceReady(baseUrl, token, role) {
             return;
         }
         if (!notified) {
-            printVerbose(`Waiting for health check: ${healthCheckUrl}`);
-            updateTask(`Waiting for application readiness (${healthCheckUrl})`);
+            if (!options?.quiet) {
+                printVerbose(`Waiting for health check: ${healthCheckUrl}`);
+                updateTask(`Waiting for application readiness (${healthCheckUrl})`);
+            }
             notified = true;
         }
         await sleep(APP_RETRY_INTERVAL);
     }
     throw new Error(`The application did not become ready in time. Expected \`${healthCheckUrl}\` to respond with \`ok\`.`);
 }
-async function waitForSwaggerSchema(baseUrl, token, role) {
+async function waitForSwaggerSchema(baseUrl, token, role, options) {
     const swaggerUrl = getSwaggerUrl(baseUrl);
     const startedAt = Date.now();
-    printVerbose(`Checking swagger schema: ${swaggerUrl}`);
+    if (!options?.quiet) {
+        printVerbose(`Checking swagger schema: ${swaggerUrl}`);
+    }
     while (Date.now() - startedAt < APP_RETRY_TIMEOUT) {
         const response = await requestJson(swaggerUrl, { token, role });
         if (response.ok) {
@@ -182,7 +186,7 @@ async function waitForSwaggerSchema(baseUrl, token, role) {
         if (!shouldRetryAppAvailability(response)) {
             return response;
         }
-        await waitForServiceReady(baseUrl, token, role);
+        await waitForServiceReady(baseUrl, token, role, options);
     }
     return await requestJson(swaggerUrl, { token, role });
 }
@@ -200,9 +204,9 @@ async function confirmEnableApiDoc() {
 async function fetchSwaggerSchema(baseUrl, token, role, context = {}, options = {}) {
     let response = options.retryAppAvailability === false
         ? await requestJson(getSwaggerUrl(baseUrl), { token, role })
-        : await waitForSwaggerSchema(baseUrl, token, role);
+        : await waitForSwaggerSchema(baseUrl, token, role, { quiet: options.quiet });
     if (response.status === 404) {
-        if (options.allowEnableApiDoc === false) {
+        if (options.allowEnableApiDoc === false || options.quiet) {
             throw new Error('`swagger:get` returned 404. Check the base URL and enable the `API documentation plugin` if needed.');
         }
         printInfo('The API documentation plugin is not enabled.');
@@ -257,7 +261,7 @@ export function formatSwaggerSchemaError(response, context) {
             `Authentication failed while loading the command runtime from \`swagger:get\`${envLabel}.`,
             `Base URL: ${context.baseUrl}`,
             details,
-            'Update the API key with `nb env add <name> --api-base-url <url> --auth-type token --token <api-key>`, log in with `nb env auth <name>`, or rerun the command with `--token <api-key>`.',
+            'Update the API key with `nb env add <name> --api-base-url <url> --auth-type token --access-token <api-key>`, log in with `nb env auth <name>`, or rerun the command with `--access-token <api-key>`.',
             commandHint,
         ].join('\n');
     }
@@ -368,10 +372,14 @@ export async function updateEnvRuntime(options) {
             .filter(Boolean)
             .join('\n'));
     }
-    updateTask('Loading command runtime...');
+    if (!options.quiet) {
+        updateTask('Loading command runtime...');
+    }
     try {
-        printVerbose(`Runtime source: ${baseUrl}`);
-        const document = await fetchSwaggerSchema(baseUrl, token, options.role, { envName });
+        if (!options.quiet) {
+            printVerbose(`Runtime source: ${baseUrl}`);
+        }
+        const document = await fetchSwaggerSchema(baseUrl, token, options.role, { envName }, { quiet: options.quiet });
         const runtime = await generateRuntime(document, options.configFile, baseUrl);
         await saveRuntime(runtime, { scope: options.scope });
         if (options.baseUrl !== undefined || options.token !== undefined) {
@@ -388,6 +396,8 @@ export async function updateEnvRuntime(options) {
         return runtime;
     }
     finally {
-        stopTask();
+        if (!options.quiet) {
+            stopTask();
+        }
     }
 }

package/dist/lib/cli-config.js

@@ -8,13 +8,21 @@
  */
 import { loadExactAuthConfig, saveAuthConfig } from './auth-store.js';
 import { resolveDefaultConfigScope } from './cli-home.js';
+import { CLI_LOCALE_FLAG_OPTIONS, normalizeCliLocale, resolveCliLocale } from './cli-locale.js';
 export const DEFAULT_LICENSE_PKG_URL = 'https://pkg.nocobase.com/';
 export const DEFAULT_DOCKER_NETWORK = 'nocobase';
 export const DEFAULT_DOCKER_CONTAINER_PREFIX = 'nb';
+export const DEFAULT_DOCKER_BIN = 'docker';
+export const DEFAULT_GIT_BIN = 'git';
+export const DEFAULT_YARN_BIN = 'yarn';
 export const SUPPORTED_CLI_CONFIG_KEYS = [
+    'locale',
     'license.pkg-url',
     'docker.network',
     'docker.container-prefix',
+    'bin.docker',
+    'bin.git',
+    'bin.yarn',
 ];
 function trimValue(value) {
     const text = String(value ?? '').trim();
@@ -36,11 +44,16 @@ export function assertSupportedCliConfigKey(value) {
 }
 function cloneSettings(config) {
     return {
+        ...(config.settings?.locale ? { locale: trimValue(config.settings.locale) } : {}),
         license: config.settings?.license ? { ...config.settings.license } : undefined,
         docker: config.settings?.docker ? { ...config.settings.docker } : undefined,
+        bin: config.settings?.bin ? { ...config.settings.bin } : undefined,
     };
 }
 function pruneSettings(config) {
+    if (config.settings && !trimValue(config.settings.locale)) {
+        delete config.settings.locale;
+    }
     const license = config.settings?.license;
     if (license && !trimValue(license.pkgUrl)) {
         delete config.settings?.license;
@@ -49,34 +62,56 @@ function pruneSettings(config) {
     if (docker && !trimValue(docker.network) && !trimValue(docker.containerPrefix)) {
         delete config.settings?.docker;
     }
-    if (config.settings
-        && !config.settings.license
-        && !config.settings.docker) {
+    const bin = config.settings?.bin;
+    if (bin && !trimValue(bin.docker) && !trimValue(bin.git) && !trimValue(bin.yarn)) {
+        delete config.settings?.bin;
+    }
+    if (config.settings &&
+        !config.settings.locale &&
+        !config.settings.license &&
+        !config.settings.docker &&
+        !config.settings.bin) {
         delete config.settings;
     }
 }
 export function getExplicitCliConfigValue(config, key) {
     switch (key) {
+        case 'locale':
+            return trimValue(config.settings?.locale);
         case 'license.pkg-url':
             return trimValue(config.settings?.license?.pkgUrl);
         case 'docker.network':
             return trimValue(config.settings?.docker?.network);
         case 'docker.container-prefix':
             return trimValue(config.settings?.docker?.containerPrefix);
+        case 'bin.docker':
+            return trimValue(config.settings?.bin?.docker);
+        case 'bin.git':
+            return trimValue(config.settings?.bin?.git);
+        case 'bin.yarn':
+            return trimValue(config.settings?.bin?.yarn);
     }
 }
 export function getEffectiveCliConfigValue(config, key) {
     const explicit = getExplicitCliConfigValue(config, key);
-    if (explicit) {
+    if (explicit && key !== 'locale') {
         return explicit;
     }
     switch (key) {
+        case 'locale':
+            return resolveCliLocale(undefined, { configuredLocale: trimValue(config.settings?.locale) });
         case 'license.pkg-url':
             return DEFAULT_LICENSE_PKG_URL;
         case 'docker.network':
             return trimValue(config.name) || DEFAULT_DOCKER_NETWORK;
         case 'docker.container-prefix':
             return trimValue(config.name) || DEFAULT_DOCKER_CONTAINER_PREFIX;
+        case 'bin.docker':
+            return DEFAULT_DOCKER_BIN;
+        case 'bin.git':
+            return DEFAULT_GIT_BIN;
+        case 'bin.yarn':
+            return DEFAULT_YARN_BIN;
     }
 }
 export function normalizeCliConfigValue(key, value) {
@@ -87,6 +122,13 @@ export function normalizeCliConfigValue(key, value) {
     if (key === 'license.pkg-url') {
         return normalized.replace(/\/+$/, '') + '/';
     }
+    if (key === 'locale') {
+        const locale = normalizeCliLocale(normalized);
+        if (!locale) {
+            throw new Error(`Config key "${key}" must be one of: ${CLI_LOCALE_FLAG_OPTIONS.join(', ')}`);
+        }
+        return locale;
+    }
     return normalized;
 }
 export async function loadCliConfig(options = {}) {
@@ -113,6 +155,9 @@ export async function setCliConfigValue(key, value, options = {}) {
     const normalized = normalizeCliConfigValue(key, value);
     config.settings = cloneSettings(config);
     switch (key) {
+        case 'locale':
+            config.settings.locale = normalized;
+            break;
         case 'license.pkg-url':
             config.settings.license = {
                 ...(config.settings.license ?? {}),
@@ -131,6 +176,24 @@ export async function setCliConfigValue(key, value, options = {}) {
                 containerPrefix: normalized,
             };
             break;
+        case 'bin.docker':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                docker: normalized,
+            };
+            break;
+        case 'bin.git':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                git: normalized,
+            };
+            break;
+        case 'bin.yarn':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                yarn: normalized,
+            };
+            break;
     }
     pruneSettings(config);
     await saveAuthConfig(config, scope);
@@ -145,6 +208,9 @@ export async function deleteCliConfigValue(key, options = {}) {
     }
     config.settings = cloneSettings(config);
     switch (key) {
+        case 'locale':
+            delete config.settings.locale;
+            break;
         case 'license.pkg-url':
             if (config.settings.license) {
                 delete config.settings.license.pkgUrl;
@@ -160,6 +226,21 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.docker.containerPrefix;
             }
             break;
+        case 'bin.docker':
+            if (config.settings.bin) {
+                delete config.settings.bin.docker;
+            }
+            break;
+        case 'bin.git':
+            if (config.settings.bin) {
+                delete config.settings.bin.git;
+            }
+            break;
+        case 'bin.yarn':
+            if (config.settings.bin) {
+                delete config.settings.bin.yarn;
+            }
+            break;
     }
     pruneSettings(config);
     await saveAuthConfig(config, scope);
@@ -174,3 +255,17 @@ export async function resolveDockerContainerPrefix(options = {}) {
 export async function resolveLicensePkgUrlFromConfig(options = {}) {
     return await getCliConfigValue('license.pkg-url', options);
 }
+const CONFIGURABLE_COMMAND_KEYS = {
+    docker: 'bin.docker',
+    git: 'bin.git',
+    yarn: 'bin.yarn',
+};
+export function isConfigurableCommandName(value) {
+    return Object.prototype.hasOwnProperty.call(CONFIGURABLE_COMMAND_KEYS, value);
+}
+export async function resolveConfiguredCommandName(commandName, options = {}) {
+    if (!isConfigurableCommandName(commandName)) {
+        return commandName;
+    }
+    return await getCliConfigValue(CONFIGURABLE_COMMAND_KEYS[commandName], options);
+}

package/dist/lib/cli-locale.js

@@ -9,12 +9,13 @@
 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 = {};
-function normalizeCliLocale(value) {
+export function normalizeCliLocale(value) {
     const raw = String(value ?? '').trim();
     if (!raw) {
         return undefined;
@@ -28,6 +29,17 @@ function normalizeCliLocale(value) {
     }
     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];
@@ -65,9 +77,11 @@ function interpolateTemplate(template, values) {
         return value === undefined || value === null ? '' : String(value);
     });
 }
-export function detectCliLocale() {
+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,
@@ -81,8 +95,8 @@ export function detectCliLocale() {
     }
     return DEFAULT_CLI_LOCALE;
 }
-export function resolveCliLocale(preferred) {
-    return normalizeCliLocale(preferred) ?? detectCliLocale();
+export function resolveCliLocale(preferred, options) {
+    return normalizeCliLocale(preferred) ?? detectCliLocale(options?.configuredLocale);
 }
 export function applyCliLocale(preferred) {
     const locale = resolveCliLocale(preferred);
@@ -111,9 +125,7 @@ export function localeText(key, values, fallback) {
     };
 }
 export function isLocalizedTextDef(value) {
-    return Boolean(value
-        && typeof value === 'object'
-        && typeof value.key === 'string');
+    return Boolean(value && typeof value === 'object' && typeof value.key === 'string');
 }
 export function resolveLocalizedText(text, options) {
     if (text === undefined) {

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

@@ -10,6 +10,7 @@ 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();
 }
@@ -117,6 +118,36 @@ async function checkMysqlFamilyConnection(config) {
         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) {
@@ -146,6 +177,19 @@ export async function checkExternalDbConnection(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) {
@@ -153,6 +197,23 @@ export async function validateExternalDbConfig(values) {
     }
     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();
 }