@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/admin/__tests__/monitoring.test.ts

@@ -0,0 +1,402 @@
+/**
+ * mysql-mcp - Admin Monitoring Tools Unit Tests
+ * 
+ * Comprehensive tests for monitoring.ts module functions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createShowProcesslistTool,
+    createShowStatusTool,
+    createShowVariablesTool,
+    createInnodbStatusTool,
+    createReplicationStatusTool,
+    createPoolStatsTool,
+    createServerHealthTool
+} from '../monitoring.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Admin Monitoring Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('createShowProcesslistTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createShowProcesslistTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_show_processlist');
+            expect(tool.group).toBe('monitoring');
+            expect(tool.requiredScopes).toContain('read');
+            expect(tool.annotations?.readOnlyHint).toBe(true);
+        });
+
+        it('should show processlist', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                { Id: 1, User: 'root', Host: 'localhost', db: 'test', Command: 'Query', Time: 0, State: 'executing', Info: 'SHOW PROCESSLIST' }
+            ]));
+
+            const tool = createShowProcesslistTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ full: true }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('SHOW FULL PROCESSLIST');
+            expect(result).toHaveProperty('processes');
+        });
+
+        it('should handle empty processlist', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createShowProcesslistTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(result).toHaveProperty('processes');
+            expect((result as { processes: unknown[] }).processes).toEqual([]);
+        });
+    });
+
+    describe('createShowStatusTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createShowStatusTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_show_status');
+            expect(tool.group).toBe('monitoring');
+            expect(tool.requiredScopes).toContain('read');
+            expect(tool.annotations?.readOnlyHint).toBe(true);
+        });
+
+        it('should show global status without filter', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([
+                { Variable_name: 'Threads_running', Value: '5' },
+                { Variable_name: 'Uptime', Value: '86400' }
+            ]));
+
+            const tool = createShowStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalledWith('SHOW GLOBAL STATUS');
+            expect(result).toHaveProperty('status');
+        });
+
+        it('should show global status with LIKE filter', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([
+                { Variable_name: 'Threads_running', Value: '5' },
+                { Variable_name: 'Threads_connected', Value: '10' }
+            ]));
+
+            const tool = createShowStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ like: 'Threads%' }, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalled();
+            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+            expect(call).toContain("LIKE 'Threads%'");
+            expect(result).toHaveProperty('status');
+        });
+
+        it('should show session status when global is false', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createShowStatusTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ global: false }, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalledWith('SHOW STATUS');
+        });
+
+        it('should handle session status with LIKE filter', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createShowStatusTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ global: false, like: 'Com_%' }, mockContext);
+
+            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+            expect(call).not.toContain('GLOBAL');
+            expect(call).toContain("LIKE 'Com_%'");
+        });
+
+        it('should transform results to key-value pairs', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([
+                { Variable_name: 'Uptime', Value: '12345' },
+                { Variable_name: 'Queries', Value: '98765' }
+            ]));
+
+            const tool = createShowStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as { status: Record<string, string> };
+
+            expect(result.status).toHaveProperty('Uptime', '12345');
+            expect(result.status).toHaveProperty('Queries', '98765');
+        });
+    });
+
+    describe('createShowVariablesTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createShowVariablesTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_show_variables');
+            expect(tool.group).toBe('monitoring');
+            expect(tool.requiredScopes).toContain('read');
+            expect(tool.annotations?.readOnlyHint).toBe(true);
+        });
+
+        it('should show global variables without filter', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([
+                { Variable_name: 'max_connections', Value: '151' }
+            ]));
+
+            const tool = createShowVariablesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalledWith('SHOW GLOBAL VARIABLES');
+            expect(result).toHaveProperty('variables');
+        });
+
+        it('should show global variables with LIKE filter', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([
+                { Variable_name: 'max_connections', Value: '151' },
+                { Variable_name: 'max_allowed_packet', Value: '67108864' }
+            ]));
+
+            const tool = createShowVariablesTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ like: 'max%' }, mockContext);
+
+            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+            expect(call).toContain("LIKE 'max%'");
+        });
+
+        it('should show session variables when global is false', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createShowVariablesTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ global: false }, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalledWith('SHOW VARIABLES');
+        });
+
+        it('should transform results to key-value pairs', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([
+                { Variable_name: 'version', Value: '8.0.33' },
+                { Variable_name: 'datadir', Value: '/var/lib/mysql/' }
+            ]));
+
+            const tool = createShowVariablesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as { variables: Record<string, string> };
+
+            expect(result.variables).toHaveProperty('version', '8.0.33');
+            expect(result.variables).toHaveProperty('datadir', '/var/lib/mysql/');
+        });
+    });
+
+    describe('createInnodbStatusTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createInnodbStatusTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_innodb_status');
+            expect(tool.group).toBe('monitoring');
+            expect(tool.requiredScopes).toContain('read');
+            expect(tool.annotations?.readOnlyHint).toBe(true);
+        });
+
+        it('should execute SHOW ENGINE INNODB STATUS', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                { Type: 'InnoDB', Name: '', Status: 'BACKGROUND THREAD\n...\nEND OF INNODB MONITOR OUTPUT' }
+            ]));
+
+            const tool = createInnodbStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('SHOW ENGINE INNODB STATUS');
+            expect(result).toHaveProperty('status');
+        });
+
+        it('should handle empty status result', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createInnodbStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(result).toHaveProperty('status');
+        });
+    });
+
+    describe('createReplicationStatusTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createReplicationStatusTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_replication_status');
+            expect(tool.group).toBe('monitoring');
+            expect(tool.requiredScopes).toContain('read');
+            expect(tool.annotations?.readOnlyHint).toBe(true);
+        });
+
+        it('should execute SHOW REPLICA STATUS', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                {
+                    Replica_IO_Running: 'Yes',
+                    Replica_SQL_Running: 'Yes',
+                    Seconds_Behind_Master: 0
+                }
+            ]));
+
+            const tool = createReplicationStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('SHOW REPLICA STATUS');
+            expect(result).toHaveProperty('status');
+        });
+
+        it('should handle no replication configured', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createReplicationStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as { status: unknown[] };
+
+            expect(result.status).toBeUndefined();
+        });
+
+        it('should fallback to SHOW SLAVE STATUS on error', async () => {
+            // First call fails (REPLICA not supported), second call succeeds
+            mockAdapter.executeQuery
+                .mockRejectedValueOnce(new Error('Unknown command REPLICA'))
+                .mockResolvedValueOnce(createMockQueryResult([{ Master_Host: 'master.db', Slave_IO_Running: 'Yes' }]));
+
+            const tool = createReplicationStatusTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
+            expect(result).toHaveProperty('status');
+        });
+    });
+
+    describe('createPoolStatsTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createPoolStatsTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_pool_stats');
+            expect(tool.group).toBe('monitoring');
+            expect(tool.requiredScopes).toContain('read');
+            expect(tool.annotations?.readOnlyHint).toBe(true);
+        });
+
+        it('should return pool statistics', async () => {
+            const mockPool = {
+                getStats: vi.fn().mockReturnValue({
+                    _allConnections: { length: 10 },
+                    _freeConnections: { length: 5 },
+                    _acquiringConnections: { length: 2 }
+                })
+            };
+            mockAdapter.getPool = vi.fn().mockReturnValue(mockPool);
+
+            const tool = createPoolStatsTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.getPool).toHaveBeenCalled();
+            expect(result).toBeDefined();
+        });
+
+        it('should handle pool not available', async () => {
+            mockAdapter.getPool = vi.fn().mockReturnValue(undefined);
+
+            const tool = createPoolStatsTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as { error: string };
+
+            expect(result.error).toBe('Pool not available');
+        });
+
+        it('should handle pool error', async () => {
+            const mockPool = {
+                getStats: vi.fn().mockImplementation(() => { throw new Error('Pool error'); })
+            };
+            mockAdapter.getPool = vi.fn().mockReturnValue(mockPool);
+
+            const tool = createPoolStatsTool(mockAdapter as unknown as MySQLAdapter);
+            await expect(tool.handler({}, mockContext)).rejects.toThrow('Pool error');
+        });
+    });
+
+    describe('createServerHealthTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createServerHealthTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_server_health');
+            expect(tool.group).toBe('monitoring');
+            expect(tool.requiredScopes).toContain('read');
+            expect(tool.annotations?.readOnlyHint).toBe(true);
+        });
+
+        it('should execute health check query', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([{ result: 1 }]));
+
+            const tool = createServerHealthTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            expect(result).toBeDefined();
+        });
+
+        it('should query server status metrics', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ Variable_name: 'Uptime', Value: '86400' }]))
+                .mockResolvedValueOnce(createMockQueryResult([{ Variable_name: 'Threads_connected', Value: '10' }]))
+                .mockResolvedValueOnce(createMockQueryResult([{ Variable_name: 'Questions', Value: '12345' }]));
+
+            const tool = createServerHealthTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as {
+                healthy?: boolean;
+                uptime?: number;
+                activeConnections?: number;
+                totalQueries?: number;
+            };
+
+            expect(result.uptime).toBe(86400);
+            expect(result.activeConnections).toBe(10);
+            expect(result.totalQueries).toBe(12345);
+        });
+
+        it('should handle missing status variables', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([]))
+                .mockResolvedValueOnce(createMockQueryResult([]))
+                .mockResolvedValueOnce(createMockQueryResult([]));
+
+            const tool = createServerHealthTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as {
+                uptime?: number;
+                activeConnections?: number;
+            };
+
+            expect(result.uptime).toBeUndefined();
+            expect(result.activeConnections).toBeUndefined();
+        });
+
+        it('should handle partial status variables', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ Variable_name: 'Uptime', Value: '3600' }]))
+                .mockResolvedValueOnce(createMockQueryResult([]))
+                .mockResolvedValueOnce(createMockQueryResult([]));
+
+            const tool = createServerHealthTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext) as {
+                uptime?: number;
+                activeConnections?: number;
+            };
+
+            expect(result.uptime).toBe(3600);
+            expect(result.activeConnections).toBeUndefined();
+        });
+
+        it('should mark unhealthy on connection failure', async () => {
+            mockAdapter.executeQuery.mockRejectedValue(new Error('Connection lost'));
+
+            const tool = createServerHealthTool(mockAdapter as unknown as MySQLAdapter);
+
+            await expect(tool.handler({}, mockContext)).rejects.toThrow();
+        });
+    });
+});

package/src/adapters/mysql/tools/admin/backup.ts

@@ -0,0 +1,238 @@
+/**
+ * MySQL Admin Tools - Backup and Restore
+ * 
+ * Tools for data export, import, and backup operations.
+ * 4 tools: export, import, dump, restore.
+ */
+
+
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+import {
+    ExportTableSchema,
+    ImportDataSchema
+} from '../../types.js';
+import { z } from 'zod';
+import { validateIdentifier, validateWhereClause } from '../../../../utils/validators.js';
+
+export function createExportTableTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_export_table',
+        title: 'MySQL Export Table',
+        description: 'Export table data as SQL INSERT statements or CSV format.',
+        group: 'backup',
+        inputSchema: ExportTableSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, format, where } = ExportTableSchema.parse(params);
+
+            // Validate inputs for SQL injection prevention
+            validateIdentifier(table, 'table');
+            if (where) {
+                validateWhereClause(where);
+            }
+
+            // Get table data
+            let sql = `SELECT * FROM \`${table}\``;
+            if (where) {
+                sql += ` WHERE ${where}`;
+            }
+
+            const result = await adapter.executeReadQuery(sql);
+            const rows = result.rows ?? [];
+
+            if (format === 'CSV') {
+                if (rows.length === 0) {
+                    return { csv: '', rowCount: 0 };
+                }
+
+                const firstRow = rows[0];
+                if (!firstRow) {
+                    return { csv: '', rowCount: 0 };
+                }
+
+                const headers = Object.keys(firstRow);
+                const csvLines = [headers.join(',')];
+
+                for (const row of rows) {
+                    const values = headers.map(h => {
+                        const val = row[h];
+                        if (val === null || val === undefined) return '';
+                        // Handle objects (JSON columns) by stringifying them
+                        if (typeof val === 'object') return `"${JSON.stringify(val).replace(/"/g, '""')}"`;
+                        if (typeof val === 'string') return `"${val.replace(/"/g, '""')}"`;
+                        // Numbers and booleans - safe to use directly
+                        if (typeof val === 'number' || typeof val === 'boolean') return `"${val}"`;
+                        return '';
+                    });
+                    csvLines.push(values.join(','));
+                }
+
+                return { csv: csvLines.join('\n'), rowCount: rows.length };
+            }
+
+            // SQL format
+            const insertStatements: string[] = [];
+
+            for (const row of rows) {
+                const columns = Object.keys(row).map(c => `\`${c}\``).join(', ');
+                const values = Object.values(row).map(v => {
+                    if (v === null || v === undefined) return 'NULL';
+                    if (typeof v === 'string') return `'${v.replace(/'/g, "''")}'`;
+                    if (typeof v === 'object') return `'${JSON.stringify(v).replace(/'/g, "''")}'`;
+                    // Numbers and booleans - safe to convert
+                    if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+                    return 'NULL';
+                }).join(', ');
+
+                insertStatements.push(`INSERT INTO \`${table}\` (${columns}) VALUES (${values});`);
+            }
+
+            return { sql: insertStatements.join('\n'), rowCount: rows.length };
+        }
+    };
+}
+
+export function createImportDataTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_import_data',
+        title: 'MySQL Import Data',
+        description: 'Import data into a table from an array of row objects.',
+        group: 'backup',
+        inputSchema: ImportDataSchema,
+        requiredScopes: ['write'],
+        annotations: {
+            readOnlyHint: false
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, data } = ImportDataSchema.parse(params);
+
+            // Validate table name for SQL injection prevention
+            validateIdentifier(table, 'table');
+
+            if (data.length === 0) {
+                return { success: true, rowsInserted: 0 };
+            }
+
+            let totalInserted = 0;
+
+            for (const row of data) {
+                // Validate column names
+                for (const colName of Object.keys(row)) {
+                    validateIdentifier(colName, 'column');
+                }
+                const columns = Object.keys(row).map(c => `\`${c}\``).join(', ');
+                const placeholders = Object.keys(row).map(() => '?').join(', ');
+                const values = Object.values(row);
+
+                const sql = `INSERT INTO \`${table}\` (${columns}) VALUES (${placeholders})`;
+                await adapter.executeWriteQuery(sql, values);
+                totalInserted++;
+            }
+
+            return { success: true, rowsInserted: totalInserted };
+        }
+    };
+}
+
+export function createCreateDumpTool(adapter: MySQLAdapter): ToolDefinition {
+    const schema = z.object({
+        database: z.string().optional().describe('Database name (defaults to current)'),
+        tables: z.array(z.string()).optional().describe('Specific tables to dump'),
+        noData: z.boolean().optional().default(false).describe('Schema only, no data'),
+        singleTransaction: z.boolean().optional().default(false).describe('Use single transaction for dump (no locking)')
+    });
+
+    return {
+        name: 'mysql_create_dump',
+        title: 'MySQL Create Dump',
+        description: 'Generate mysqldump command for backing up database.',
+        group: 'backup',
+        inputSchema: schema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { database, tables, noData, singleTransaction } = schema.parse(params);
+
+            // Get current database if not specified
+            let dbName = database;
+            if (!dbName) {
+                const result = await adapter.executeReadQuery('SELECT DATABASE() as db');
+                const dbValue = result.rows?.[0]?.['db'];
+                if (typeof dbValue === 'string') {
+                    dbName = dbValue;
+                } else {
+                    dbName = '';
+                }
+            }
+
+            let command = `mysqldump -u [username] -p ${dbName}`;
+
+            if (tables && tables.length > 0) {
+                command += ` ${tables.join(' ')}`;
+            }
+
+            if (noData) {
+                command += ' --no-data';
+            }
+
+            if (singleTransaction) {
+                command += ' --single-transaction';
+            }
+
+            command += ' > backup.sql';
+
+            return {
+                command,
+                note: 'Replace [username] with your MySQL username. Add -h [host] if connecting to a remote server.'
+            };
+        }
+    };
+}
+
+export function createRestoreDumpTool(adapter: MySQLAdapter): ToolDefinition {
+    const schema = z.object({
+        database: z.string().optional().describe('Target database'),
+        filename: z.string().default('backup.sql').describe('Dump file to restore')
+    });
+
+    return {
+        name: 'mysql_restore_dump',
+        title: 'MySQL Restore Dump',
+        description: 'Generate command for restoring from mysqldump backup.',
+        group: 'backup',
+        inputSchema: schema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { database, filename } = schema.parse(params);
+
+            let dbName = database;
+            if (!dbName) {
+                const result = await adapter.executeReadQuery('SELECT DATABASE() as db');
+                const dbValue = result.rows?.[0]?.['db'];
+                if (typeof dbValue === 'string') {
+                    dbName = dbValue;
+                } else {
+                    dbName = '';
+                }
+            }
+
+            const command = `mysql -u [username] -p ${dbName} < ${filename}`;
+
+            return {
+                command,
+                note: 'Replace [username] with your MySQL username. Add -h [host] if connecting to a remote server.'
+            };
+        }
+    };
+}