spindb 0.46.4 → 0.47.0

package/dist/engines/mariadb/index.js

@@ -3,15 +3,15 @@
  * Manages MariaDB database containers using pre-built binaries from hostdb
  */
 import { spawn, exec } from 'child_process';
-import { promisify } from 'util';
 import { existsSync, createReadStream } from 'fs';
 import { mkdir, writeFile, readFile, unlink, rm } from 'fs/promises';
 import { join } from 'path';
 import { BaseEngine } from '../base-engine.js';
 import { paths } from '../../config/paths.js';
 import { getEngineDefaults } from '../../config/defaults.js';
-import { platformService, isWindows, getWindowsSpawnOptions, } from '../../core/platform-service.js';
+import { platformService, isWindows, } from '../../core/platform-service.js';
 import { configManager } from '../../core/config-manager.js';
+import { getDefaultUsername, loadCredentials, } from '../../core/credential-manager.js';
 import { logDebug, logWarning, ErrorCodes, SpinDBError, assertValidDatabaseName, assertValidUsername, } from '../../core/error-handler.js';
 import { mariadbBinaryManager } from './binary-manager.js';
 import { getBinaryUrl } from './binary-urls.js';
@@ -19,44 +19,77 @@ import { fetchAvailableVersions, getLatestVersion } from './hostdb-releases.js';
 import { SUPPORTED_MAJOR_VERSIONS, MARIADB_VERSION_MAP } from './version-maps.js';
 import { detectBackupFormat as detectBackupFormatImpl, restoreBackup, parseConnectionString, } from './restore.js';
 import { createBackup } from './backup.js';
-import { Platform, } from '../../types/index.js';
+import { buildMariaDbEnv } from './env.js';
+import { Engine, Platform, } from '../../types/index.js';
 import { parseTSVToQueryResult } from '../../core/query-parser.js';
 import { getLibraryEnv, detectLibraryError } from '../../core/library-env.js';
-const execAsync = promisify(exec);
 const ENGINE = 'mariadb';
 const engineDef = getEngineDefaults(ENGINE);
-// Build a Windows-safe mariadb command string for either a file or inline SQL.
-export function buildWindowsMariadbCommand(mysqlPath, port, user, db, options) {
-    if (!options.file && !options.sql) {
-        throw new Error('Either file or sql option must be provided');
-    }
-    let cmd = `"${mysqlPath}" -h 127.0.0.1 -P ${port} -u ${user} ${db}`;
-    if (options.file) {
-        cmd += ` < "${options.file}"`;
-    }
-    else if (options.sql) {
-        const escaped = options.sql.replace(/"/g, '\\"');
-        cmd += ` -e "${escaped}"`;
-    }
-    return cmd;
-}
-// Build a platform-safe mariadb command string with SQL inline.
-export function buildMariadbInlineCommand(mysqlPath, port, user, sql, options = {}) {
-    const dbArg = options.database ? ` ${options.database}` : '';
-    if (isWindows()) {
-        const escaped = sql.replace(/"/g, '\\"');
-        return `"${mysqlPath}" -h 127.0.0.1 -P ${port} -u ${user}${dbArg} -e "${escaped}"`;
-    }
-    else {
-        const escaped = sql.replace(/'/g, "'\\''");
-        return `"${mysqlPath}" -h 127.0.0.1 -P ${port} -u ${user}${dbArg} -e '${escaped}'`;
-    }
+async function runMariaDbBinary(binaryPath, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(binaryPath, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: buildMariaDbEnv(options.password),
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let timeoutId;
+        let timeoutError = null;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve({ stdout, stderr });
+            }
+        };
+        if (options.timeout && options.timeout > 0) {
+            timeoutId = setTimeout(() => {
+                timeoutError = new Error(`mariadb command timed out after ${options.timeout}ms`);
+                proc.kill();
+            }, options.timeout);
+        }
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('error', (error) => {
+            finish(error);
+        });
+        proc.on('close', (code) => {
+            if (timeoutError) {
+                finish(timeoutError);
+                return;
+            }
+            if (code === 0) {
+                finish();
+                return;
+            }
+            finish(new Error(stderr || `mariadb exited with code ${code}`));
+        });
+    });
 }
 export class MariaDBEngine extends BaseEngine {
     name = ENGINE;
     displayName = 'MariaDB';
     defaultPort = engineDef.defaultPort;
     supportedVersions = SUPPORTED_MAJOR_VERSIONS;
+    async getLocalAdminAuth(containerName) {
+        const savedCreds = await loadCredentials(containerName, Engine.MariaDB, getDefaultUsername(Engine.MariaDB));
+        return {
+            user: savedCreds?.username || engineDef.superuser,
+            password: savedCreds?.password,
+        };
+    }
     async fetchAvailableVersions() {
         return fetchAvailableVersions();
     }
@@ -280,17 +313,11 @@ export class MariaDBEngine extends BaseEngine {
         const libraryEnv = getLibraryEnv(binPath);
         if (isWindows()) {
             proc = spawn(mysqld, args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
+                stdio: ['ignore', 'ignore', 'ignore'],
                 detached: true,
                 windowsHide: true,
                 env: { ...process.env, ...libraryEnv },
             });
-            proc.stdout?.on('data', (data) => {
-                logDebug(`mariadbd stdout: ${data.toString()}`);
-            });
-            proc.stderr?.on('data', (data) => {
-                logDebug(`mariadbd stderr: ${data.toString()}`);
-            });
             proc.unref();
         }
         else {
@@ -335,7 +362,10 @@ export class MariaDBEngine extends BaseEngine {
                     attempts++;
                     try {
                         const mysqladmin = await this.getMysqladminPath();
-                        await execAsync(`"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root ping`);
+                        const auth = await this.getLocalAdminAuth(container.name);
+                        await runMariaDbBinary(mysqladmin, ['-h', '127.0.0.1', '-P', String(port), '-u', auth.user, 'ping'], {
+                            password: auth.password,
+                        });
                         if (settled)
                             return;
                         settled = true;
@@ -393,22 +423,26 @@ export class MariaDBEngine extends BaseEngine {
     async stop(container) {
         const { name, port } = container;
         const pidFile = paths.getContainerPidPath(name, { engine: ENGINE });
+        const auth = await this.getLocalAdminAuth(name);
         logDebug(`Stopping MariaDB container "${name}" on port ${port}`);
         const pid = await this.getValidatedPid(pidFile);
         if (pid === null) {
             logDebug('No valid PID, checking if MariaDB is responding on port');
             try {
                 const mysqladmin = await this.getMysqladminPath();
-                await execAsync(`"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root ping`, { timeout: 2000 });
+                await runMariaDbBinary(mysqladmin, ['-h', '127.0.0.1', '-P', String(port), '-u', auth.user, 'ping'], {
+                    timeout: 2000,
+                    password: auth.password,
+                });
                 logWarning(`MariaDB responding on port ${port} but no valid PID file`);
-                await this.gracefulShutdown(port);
+                await this.gracefulShutdown(port, auth);
             }
             catch {
                 logDebug('MariaDB not responding, nothing to stop');
             }
             return;
         }
-        const gracefulSuccess = await this.gracefulShutdown(port, pid);
+        const gracefulSuccess = await this.gracefulShutdown(port, auth, pid);
         if (gracefulSuccess) {
             await this.cleanupPidFile(pidFile);
             logDebug('MariaDB stopped gracefully');
@@ -447,11 +481,14 @@ export class MariaDBEngine extends BaseEngine {
             return null;
         }
     }
-    async gracefulShutdown(port, pid, timeoutMs = 10000) {
+    async gracefulShutdown(port, auth, pid, timeoutMs = 10000) {
         try {
             const mysqladmin = await this.getMysqladminPath();
             logDebug('Attempting mysqladmin shutdown');
-            await execAsync(`"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root shutdown`, { timeout: 5000 });
+            await runMariaDbBinary(mysqladmin, ['-h', '127.0.0.1', '-P', String(port), '-u', auth.user, 'shutdown'], {
+                timeout: 5000,
+                password: auth.password,
+            });
         }
         catch (error) {
             const e = error;
@@ -545,7 +582,10 @@ export class MariaDBEngine extends BaseEngine {
         }
         try {
             const mysqladmin = await this.getMysqladminPath();
-            await execAsync(`"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root ping`);
+            const auth = await this.getLocalAdminAuth(name);
+            await runMariaDbBinary(mysqladmin, ['-h', '127.0.0.1', '-P', String(port), '-u', auth.user, 'ping'], {
+                password: auth.password,
+            });
             return { running: true, message: 'MariaDB is running' };
         }
         catch {
@@ -556,16 +596,19 @@ export class MariaDBEngine extends BaseEngine {
         return detectBackupFormatImpl(filePath);
     }
     async restore(container, backupPath, options = {}) {
-        const { port, version } = container;
+        const { name, port, version } = container;
         const database = options.database || container.database;
         const binPath = this.getBinaryPath(version);
+        const auth = await this.getLocalAdminAuth(name);
         if (options.createDatabase !== false) {
             await this.createDatabase(container, database);
         }
         return restoreBackup(backupPath, {
+            containerName: name,
             port,
             database,
-            user: engineDef.superuser,
+            user: auth.user,
+            password: auth.password,
             createDatabase: false,
             validateVersion: options.validateVersion !== false,
             binPath,
@@ -591,26 +634,38 @@ export class MariaDBEngine extends BaseEngine {
             '  spindb engines download mariadb');
     }
     async connect(container, database) {
-        const { port } = container;
+        const { name, port } = container;
         const db = database || container.database || 'mysql';
         const mysql = await this.getMariadbClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         const spawnOptions = {
             stdio: 'inherit',
-            ...getWindowsSpawnOptions(),
+            env: buildMariaDbEnv(auth.password),
         };
         return new Promise((resolve, reject) => {
-            const proc = spawn(mysql, ['-h', '127.0.0.1', '-P', String(port), '-u', engineDef.superuser, db], spawnOptions);
+            const proc = spawn(mysql, ['-h', '127.0.0.1', '-P', String(port), '-u', auth.user, db], spawnOptions);
             proc.on('error', reject);
             proc.on('close', () => resolve());
         });
     }
     async createDatabase(container, database) {
         assertValidDatabaseName(database);
-        const { port } = container;
+        const { name, port } = container;
         const mysql = await this.getMariadbClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         try {
-            const cmd = buildMariadbInlineCommand(mysql, port, engineDef.superuser, `CREATE DATABASE IF NOT EXISTS \`${database}\``);
-            await execAsync(cmd);
+            await runMariaDbBinary(mysql, [
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(port),
+                '-u',
+                auth.user,
+                '-e',
+                `CREATE DATABASE IF NOT EXISTS \`${database}\``,
+            ], {
+                password: auth.password,
+            });
         }
         catch (error) {
             const err = error;
@@ -621,11 +676,22 @@ export class MariaDBEngine extends BaseEngine {
     }
     async dropDatabase(container, database) {
         assertValidDatabaseName(database);
-        const { port } = container;
+        const { name, port } = container;
         const mysql = await this.getMariadbClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         try {
-            const cmd = buildMariadbInlineCommand(mysql, port, engineDef.superuser, `DROP DATABASE IF EXISTS \`${database}\``);
-            await execAsync(cmd);
+            await runMariaDbBinary(mysql, [
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(port),
+                '-u',
+                auth.user,
+                '-e',
+                `DROP DATABASE IF EXISTS \`${database}\``,
+            ], {
+                password: auth.password,
+            });
         }
         catch (error) {
             const err = error;
@@ -635,12 +701,25 @@ export class MariaDBEngine extends BaseEngine {
         }
     }
     async getDatabaseSize(container) {
-        const { port, database } = container;
+        const { name, port, database } = container;
         const db = database || 'mysql';
         assertValidDatabaseName(db);
         try {
             const mysql = await this.getMariadbClientPath();
-            const { stdout } = await execAsync(`"${mysql}" -h 127.0.0.1 -P ${port} -u ${engineDef.superuser} -N -e "SELECT COALESCE(SUM(data_length + index_length), 0) FROM information_schema.tables WHERE table_schema = '${db}'"`);
+            const auth = await this.getLocalAdminAuth(name);
+            const { stdout } = await runMariaDbBinary(mysql, [
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(port),
+                '-u',
+                auth.user,
+                '-N',
+                '-e',
+                `SELECT COALESCE(SUM(data_length + index_length), 0) FROM information_schema.tables WHERE table_schema = '${db}'`,
+            ], {
+                password: auth.password,
+            });
             const size = parseInt(stdout.trim(), 10);
             return isNaN(size) ? null : size;
         }
@@ -651,26 +730,6 @@ export class MariaDBEngine extends BaseEngine {
     async dumpFromConnectionString(connectionString, outputPath) {
         const dumpPath = await this.getDumpPath();
         const { host, port, user, password, database } = parseConnectionString(connectionString);
-        if (isWindows()) {
-            const cmd = `"${dumpPath}" -h ${host} -P ${port} -u ${user} --result-file "${outputPath}" ${database}`;
-            const execOptions = {};
-            if (password) {
-                execOptions.env = { ...process.env, MYSQL_PWD: password };
-            }
-            try {
-                logDebug('Executing mariadb-dump command', { cmd });
-                await execAsync(cmd, execOptions);
-                return {
-                    filePath: outputPath,
-                    stdout: '',
-                    stderr: '',
-                    code: 0,
-                };
-            }
-            catch (error) {
-                throw new Error(error.message);
-            }
-        }
         const args = [
             '-h',
             host,
@@ -684,8 +743,7 @@ export class MariaDBEngine extends BaseEngine {
         ];
         const spawnOptions = {
             stdio: ['pipe', 'pipe', 'pipe'],
-            ...getWindowsSpawnOptions(),
-            env: password ? { ...process.env, MYSQL_PWD: password } : process.env,
+            env: buildMariaDbEnv(password),
         };
         return new Promise((resolve, reject) => {
             const proc = spawn(dumpPath, args, spawnOptions);
@@ -725,26 +783,51 @@ export class MariaDBEngine extends BaseEngine {
     }
     async terminateConnections(container, database) {
         assertValidDatabaseName(database);
-        const { port } = container;
+        const { name, port } = container;
         const mysql = await this.getMariadbClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         // Get all connection IDs for the target database and kill them
         // We need to do this in two steps since MariaDB doesn't support subqueries in KILL
-        const getIdsCmd = buildMariadbInlineCommand(mysql, port, engineDef.superuser, `SELECT ID FROM information_schema.PROCESSLIST WHERE DB = '${database}' AND ID != CONNECTION_ID()`);
+        const getIdsArgs = [
+            mysql,
+            '-h',
+            '127.0.0.1',
+            '-P',
+            String(port),
+            '-u',
+            auth.user,
+            '-N',
+            '-B',
+            '-e',
+            `SELECT ID FROM information_schema.PROCESSLIST WHERE DB = '${database}' AND ID != CONNECTION_ID()`,
+        ];
         try {
-            const { stdout } = await execAsync(getIdsCmd);
+            const { stdout } = await runMariaDbBinary(getIdsArgs[0], getIdsArgs.slice(1), {
+                password: auth.password,
+            });
             const lines = stdout
                 .trim()
                 .split('\n')
                 .filter((l) => l.trim());
-            // Skip header row if present
             const ids = lines
-                .slice(1)
                 .map((l) => l.trim())
                 .filter((l) => /^\d+$/.test(l));
             for (const id of ids) {
-                const killCmd = buildMariadbInlineCommand(mysql, port, engineDef.superuser, `KILL CONNECTION ${id}`);
+                const killArgs = [
+                    mysql,
+                    '-h',
+                    '127.0.0.1',
+                    '-P',
+                    String(port),
+                    '-u',
+                    auth.user,
+                    '-e',
+                    `KILL CONNECTION ${id}`,
+                ];
                 try {
-                    await execAsync(killCmd);
+                    await runMariaDbBinary(killArgs[0], killArgs.slice(1), {
+                        password: auth.password,
+                    });
                 }
                 catch {
                     // Connection may already be gone
@@ -756,38 +839,25 @@ export class MariaDBEngine extends BaseEngine {
         }
     }
     async runScript(container, options) {
-        const { port } = container;
+        const { name, port } = container;
         const db = options.database || container.database || 'mysql';
         assertValidDatabaseName(db);
         const mysql = await this.getMariadbClientPath();
-        if (isWindows()) {
-            const cmd = buildWindowsMariadbCommand(mysql, port, engineDef.superuser, db, options);
-            try {
-                const { stdout, stderr } = await execAsync(cmd);
-                if (stdout)
-                    process.stdout.write(stdout);
-                if (stderr)
-                    process.stderr.write(stderr);
-                return;
-            }
-            catch (error) {
-                const err = error;
-                throw new Error(`mariadb client failed: ${err.message}`);
-            }
-        }
+        const auth = await this.getLocalAdminAuth(name);
         const args = [
             '-h',
             '127.0.0.1',
             '-P',
             String(port),
             '-u',
-            engineDef.superuser,
+            auth.user,
             db,
         ];
         if (options.sql) {
             args.push('-e', options.sql);
             const spawnOptions = {
                 stdio: 'inherit',
+                env: buildMariaDbEnv(auth.password),
             };
             return new Promise((resolve, reject) => {
                 const proc = spawn(mysql, args, spawnOptions);
@@ -805,6 +875,7 @@ export class MariaDBEngine extends BaseEngine {
         else if (options.file) {
             const spawnOptions = {
                 stdio: ['pipe', 'inherit', 'inherit'],
+                env: buildMariaDbEnv(auth.password),
             };
             return new Promise((resolve, reject) => {
                 const fileStream = createReadStream(options.file);
@@ -830,12 +901,17 @@ export class MariaDBEngine extends BaseEngine {
         }
     }
     async executeQuery(container, query, options) {
-        const { port } = container;
+        const { name, port } = container;
         const db = options?.database || container.database || 'mysql';
         assertValidDatabaseName(db);
         const mariadb = await this.getMariadbClientPath();
         const host = options?.host ?? '127.0.0.1';
-        const user = options?.username || engineDef.superuser;
+        const localAuth = !options?.username &&
+            !options?.password &&
+            (host === '127.0.0.1' || host === 'localhost')
+            ? await this.getLocalAdminAuth(name)
+            : null;
+        const user = options?.username || localAuth?.user || engineDef.superuser;
         // Use -B (batch mode) for tab-separated output
         const args = [
             '-h',
@@ -853,9 +929,7 @@ export class MariaDBEngine extends BaseEngine {
             args.push('--ssl');
         }
         // Pass password via env to avoid exposing it in process listings
-        const env = options?.password
-            ? { ...process.env, MYSQL_PWD: options.password }
-            : process.env;
+        const env = buildMariaDbEnv(options?.password ?? localAuth?.password);
         return new Promise((resolve, reject) => {
             const proc = spawn(mariadb, args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
@@ -885,8 +959,9 @@ export class MariaDBEngine extends BaseEngine {
      * (information_schema, mysql, performance_schema, sys).
      */
     async listDatabases(container) {
-        const { port } = container;
+        const { name, port } = container;
         const mariadb = await this.getMariadbClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         // Query for all non-system databases
         const sql = `SHOW DATABASES WHERE \`Database\` NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')`;
         const args = [
@@ -895,7 +970,7 @@ export class MariaDBEngine extends BaseEngine {
             '-P',
             String(port),
             '-u',
-            engineDef.superuser,
+            auth.user,
             '-N', // Skip column names
             '-B', // Batch mode (no formatting)
             '-e',
@@ -904,6 +979,7 @@ export class MariaDBEngine extends BaseEngine {
         return new Promise((resolve, reject) => {
             const proc = spawn(mariadb, args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
+                env: buildMariaDbEnv(auth.password),
             });
             let stdout = '';
             let stderr = '';
@@ -932,10 +1008,11 @@ export class MariaDBEngine extends BaseEngine {
     async createUser(container, options) {
         const { username, password, database } = options;
         assertValidUsername(username);
-        const { port } = container;
+        const { name, port } = container;
         const db = database || container.database || 'mysql';
         assertValidDatabaseName(db);
         const mariadb = await this.getMariadbClientPath();
+        const auth = await this.getLocalAdminAuth(name);
         // Check if NO_BACKSLASH_ESCAPES is enabled — if so, only escape single quotes
         let noBackslashEscapes = false;
         try {
@@ -945,7 +1022,7 @@ export class MariaDBEngine extends BaseEngine {
                 '-P',
                 String(port),
                 '-u',
-                engineDef.superuser,
+                auth.user,
                 '-N',
                 '-B',
                 '-e',
@@ -954,6 +1031,7 @@ export class MariaDBEngine extends BaseEngine {
             const modeResult = await new Promise((resolve, reject) => {
                 const proc = spawn(mariadb, modeArgs, {
                     stdio: ['pipe', 'pipe', 'pipe'],
+                    env: buildMariaDbEnv(auth.password),
                 });
                 let stdout = '';
                 proc.stdout?.on('data', (data) => {
@@ -983,11 +1061,12 @@ export class MariaDBEngine extends BaseEngine {
             '-P',
             String(port),
             '-u',
-            engineDef.superuser,
+            auth.user,
         ];
         await new Promise((resolve, reject) => {
             const proc = spawn(mariadb, args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
+                env: buildMariaDbEnv(auth.password),
             });
             let stderr = '';
             proc.stderr?.on('data', (data) => {