@hesed/mysql 0.2.1 → 0.3.0

package/dist/commands/mysql/indexes.js

@@ -1,5 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
-import { closeConnections, getMySQLConfig, setConfigDir, showIndexes } from '../../mysql/index.js';
+import { closeConnections, showIndexes } from '../../mysql/index.js';
 export default class MySQLIndexes extends Command {
     static args = {
         table: Args.string({ description: 'Table name to show indexes for', required: true }),
@@ -19,15 +19,7 @@ export default class MySQLIndexes extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(MySQLIndexes);
-        setConfigDir(this.config.configDir);
-        let profile;
-        try {
-            profile = flags.profile ?? (await getMySQLConfig()).defaultProfile;
-        }
-        catch (error) {
-            this.error(error instanceof Error ? error.message : String(error));
-        }
-        const result = await showIndexes(profile, args.table, flags.format);
+        const result = await showIndexes(this.config, args.table, flags.profile, flags.format);
         await closeConnections();
         if (result.success) {
             this.log(result.result ?? '');

package/dist/commands/mysql/query.js

@@ -1,5 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
-import { closeConnections, executeQuery, getMySQLConfig, setConfigDir } from '../../mysql/index.js';
+import { closeConnections, executeQuery } from '../../mysql/index.js';
 export default class MySQLQuery extends Command {
     static args = {
         query: Args.string({ description: 'SQL query to execute', required: true }),
@@ -24,15 +24,7 @@ export default class MySQLQuery extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(MySQLQuery);
-        setConfigDir(this.config.configDir);
-        let profile;
-        try {
-            profile = flags.profile ?? (await getMySQLConfig()).defaultProfile;
-        }
-        catch (error) {
-            this.error(error instanceof Error ? error.message : String(error));
-        }
-        const result = await executeQuery(args.query, profile, flags.format, flags['skip-confirmation']);
+        const result = await executeQuery(this.config, args.query, flags.profile, flags.format, flags['skip-confirmation']);
         await closeConnections();
         if (result.success) {
             this.log(result.result ?? '');

package/dist/commands/mysql/tables.js

@@ -1,5 +1,5 @@
 import { Command, Flags } from '@oclif/core';
-import { closeConnections, getMySQLConfig, listTables, setConfigDir } from '../../mysql/index.js';
+import { closeConnections, listTables } from '../../mysql/index.js';
 export default class MySQLTables extends Command {
     static description = 'List all tables in the current MySQL database';
     static examples = [
@@ -11,15 +11,7 @@ export default class MySQLTables extends Command {
     };
     async run() {
         const { flags } = await this.parse(MySQLTables);
-        setConfigDir(this.config.configDir);
-        let profile;
-        try {
-            profile = flags.profile ?? (await getMySQLConfig()).defaultProfile;
-        }
-        catch (error) {
-            this.error(error instanceof Error ? error.message : String(error));
-        }
-        const result = await listTables(profile);
+        const result = await listTables(this.config, flags.profile);
         await closeConnections();
         if (result.success) {
             this.logJson(result.tables);

package/dist/mysql/config-loader.d.ts

@@ -1,32 +1,23 @@
 import type { ConnectionOptions as MySQL2ConnectionOptions } from 'mysql2/promise';
-import type { DatabaseProfile } from '../config.js';
-/**
- * Safety configuration for query execution
- */
+export interface DatabaseProfile {
+    database: string;
+    host: string;
+    password: string;
+    port: number;
+    ssl?: boolean;
+    user: string;
+}
 interface SafetyConfig {
     blacklistedOperations: string[];
     defaultLimit: number;
     requireConfirmationFor: string[];
 }
-/**
- * Main configuration structure
- */
 export interface MySQLConfig {
     defaultFormat: 'csv' | 'json' | 'table' | 'toon';
     defaultProfile: string;
     profiles: Record<string, DatabaseProfile>;
     safety: SafetyConfig;
 }
-/**
- * MySQL connection options for mysql2 driver
- */
 type MySQLConnectionOptions = Pick<MySQL2ConnectionOptions, 'connectTimeout' | 'database' | 'host' | 'multipleStatements' | 'password' | 'port' | 'ssl' | 'user'>;
-/**
- * Get MySQL connection options for a specific profile
- *
- * @param config - Configuration object
- * @param profileName - Profile name
- * @returns MySQL connection options
- */
 export declare function getMySQLConnectionOptions(config: MySQLConfig, profileName: string): MySQLConnectionOptions;
 export {};

package/dist/mysql/config-loader.js

@@ -1,10 +1,3 @@
-/**
- * Get MySQL connection options for a specific profile
- *
- * @param config - Configuration object
- * @param profileName - Profile name
- * @returns MySQL connection options
- */
 export function getMySQLConnectionOptions(config, profileName) {
     const profile = config.profiles[profileName];
     if (!profile) {

package/dist/mysql/database.d.ts

@@ -1,10 +1,3 @@
-/**
- * Database abstraction interface
- * Defines the contract for the MySQL utility implementation
- */
-/**
- * Query execution result for SELECT/SHOW/DESCRIBE/EXPLAIN queries
- */
 export interface QueryResult {
     error?: string;
     message?: string;
@@ -12,54 +5,36 @@ export interface QueryResult {
     result?: string;
     success: boolean;
 }
-/**
- * Database list result
- */
 export interface DatabaseListResult {
     databases?: string[];
     error?: string;
     result?: string;
     success: boolean;
 }
-/**
- * Table list result
- */
 export interface TableListResult {
     error?: string;
     result?: string;
     success: boolean;
     tables?: string[];
 }
-/**
- * Table structure result
- */
 export interface TableStructureResult {
     error?: string;
     result?: string;
     structure?: Record<string, unknown>[];
     success: boolean;
 }
-/**
- * Index information result
- */
 export interface IndexResult {
     error?: string;
     indexes?: Record<string, unknown>[];
     result?: string;
     success: boolean;
 }
-/**
- * Query plan result
- */
 export interface ExplainResult {
     error?: string;
     plan?: Record<string, unknown>[];
     result?: string;
     success: boolean;
 }
-/**
- * Connection test result
- */
 export interface ConnectionTestResult {
     database?: string;
     error?: string;
@@ -67,13 +42,7 @@ export interface ConnectionTestResult {
     success: boolean;
     version?: string;
 }
-/**
- * Output format type
- */
 export type OutputFormat = 'csv' | 'json' | 'table' | 'toon';
-/**
- * Database utility interface
- */
 export interface DatabaseUtil {
     closeAll(): Promise<void>;
     describeTable(profileName: string, table: string, format?: OutputFormat): Promise<TableStructureResult>;

package/dist/mysql/database.js

@@ -1,5 +1 @@
-/**
- * Database abstraction interface
- * Defines the contract for the MySQL utility implementation
- */
 export {};

package/dist/mysql/formatters.d.ts

@@ -0,0 +1,5 @@
+import type { FieldPacket, RowDataPacket } from 'mysql2/promise';
+import type { OutputFormat } from './database.js';
+type Formatter = (rows: RowDataPacket[], fields: FieldPacket[]) => string;
+export declare const FORMATTERS: Record<OutputFormat, Formatter>;
+export {};

package/dist/mysql/formatters.js

@@ -0,0 +1,76 @@
+import { encode } from '@toon-format/toon';
+function formatAsCsv(rows, fields) {
+    if (!rows || rows.length === 0) {
+        return '';
+    }
+    const columnNames = fields.map((f) => f.name);
+    let csv = columnNames.join(',') + '\n';
+    for (const row of rows) {
+        const values = columnNames.map((name) => {
+            const value = row[name] ?? '';
+            const str = String(value);
+            if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+                return '"' + str.replaceAll('"', '""') + '"';
+            }
+            return str;
+        });
+        csv += values.join(',') + '\n';
+    }
+    return csv;
+}
+function formatAsJson(rows) {
+    return JSON.stringify(rows, null, 2);
+}
+function formatAsTable(rows, fields) {
+    if (!rows || rows.length === 0) {
+        return 'No results';
+    }
+    const columnNames = fields.map((f) => f.name);
+    const columnWidths = columnNames.map((name) => {
+        const dataWidth = Math.max(...rows.map((row) => String(row[name] ?? '').length));
+        return Math.max(name.length, dataWidth, 3);
+    });
+    let table = '┌' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┬') + '┐\n';
+    table += '│ ' + columnNames.map((name, i) => name.padEnd(columnWidths[i])).join(' │ ') + ' │\n';
+    table += '├' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┼') + '┤\n';
+    for (const row of rows) {
+        table +=
+            '│ ' +
+                columnNames
+                    .map((name, i) => {
+                    const value = row[name] ?? 'NULL';
+                    return String(value).padEnd(columnWidths[i]);
+                })
+                    .join(' │ ') +
+                ' │\n';
+    }
+    table += '└' + columnWidths.map((w) => '─'.repeat(w + 2)).join('┴') + '┘';
+    return table;
+}
+function formatAsToon(rows) {
+    if (!rows || rows.length === 0) {
+        return '';
+    }
+    const serializedRows = rows.map((row) => {
+        const serialized = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (value instanceof Date) {
+                serialized[key] = Number.isNaN(value.getTime()) ? null : value.toISOString();
+            }
+            else if (Buffer.isBuffer(value)) {
+                serialized[key] = value.toString('base64');
+            }
+            else {
+                serialized[key] = value;
+            }
+        }
+        return serialized;
+    });
+    return encode(serializedRows);
+}
+export const FORMATTERS = {
+    csv: formatAsCsv,
+    json: formatAsJson,
+    table: formatAsTable,
+    toon: formatAsToon,
+};

package/dist/mysql/index.d.ts

@@ -1,3 +1 @@
-export type { MySQLJsonConfig } from '../config.js';
-export type { ConnectionTestResult } from './database.js';
-export { closeConnections, describeTable, executeQuery, explainQuery, getMySQLConfig, listDatabases, listTables, setConfigDir, showIndexes, testDirectConnection, } from './mysql-client.js';
+export { closeConnections, describeTable, executeQuery, explainQuery, listDatabases, listTables, showIndexes, testDirectConnection, } from './mysql-client.js';

package/dist/mysql/index.js

@@ -1 +1 @@
-export { closeConnections, describeTable, executeQuery, explainQuery, getMySQLConfig, listDatabases, listTables, setConfigDir, showIndexes, testDirectConnection, } from './mysql-client.js';
+export { closeConnections, describeTable, executeQuery, explainQuery, listDatabases, listTables, showIndexes, testDirectConnection, } from './mysql-client.js';

package/dist/mysql/mysql-client.d.ts

@@ -1,60 +1,11 @@
-import type { DatabaseProfile } from '../config.js';
-import type { MySQLConfig } from './config-loader.js';
+import type { Config } from '@oclif/core';
+import type { DatabaseProfile } from './config-loader.js';
 import type { ConnectionTestResult, DatabaseListResult, ExplainResult, IndexResult, OutputFormat, QueryResult, TableListResult, TableStructureResult } from './database.js';
-/**
- * Set the config directory for the singleton client
- * @param dir - Oclif config directory path
- */
-export declare function setConfigDir(dir: string): void;
-/**
- * Get the loaded MySQL config, initializing if needed
- */
-export declare function getMySQLConfig(): Promise<MySQLConfig>;
-/**
- * Execute SQL query
- * @param query - SQL query to execute
- * @param profile - Database profile name
- * @param format - Output format
- * @param skipConfirmation - Skip confirmation for destructive operations
- */
-export declare function executeQuery(query: string, profile: string, format?: OutputFormat, skipConfirmation?: boolean): Promise<QueryResult>;
-/**
- * List all databases
- * @param profile - Database profile name
- */
-export declare function listDatabases(profile: string): Promise<DatabaseListResult>;
-/**
- * List all tables in current database
- * @param profile - Database profile name
- */
-export declare function listTables(profile: string): Promise<TableListResult>;
-/**
- * Describe table structure
- * @param profile - Database profile name
- * @param table - Table name
- * @param format - Output format
- */
-export declare function describeTable(profile: string, table: string, format?: 'json' | 'table' | 'toon'): Promise<TableStructureResult>;
-/**
- * Show table indexes
- * @param profile - Database profile name
- * @param table - Table name
- * @param format - Output format
- */
-export declare function showIndexes(profile: string, table: string, format?: 'json' | 'table' | 'toon'): Promise<IndexResult>;
-/**
- * Explain query execution plan
- * @param profile - Database profile name
- * @param query - SQL query to explain
- * @param format - Output format
- */
-export declare function explainQuery(profile: string, query: string, format?: 'json' | 'table' | 'toon'): Promise<ExplainResult>;
-/**
- * Test a connection directly with profile options (without loading JSON config)
- * @param profile - Database connection profile options
- */
+export declare function executeQuery(config: Config, query: string, profile?: string, format?: OutputFormat, skipConfirmation?: boolean): Promise<QueryResult>;
+export declare function listDatabases(config: Config, profile?: string): Promise<DatabaseListResult>;
+export declare function listTables(config: Config, profile?: string): Promise<TableListResult>;
+export declare function describeTable(config: Config, table: string, profile?: string, format?: 'json' | 'table' | 'toon'): Promise<TableStructureResult>;
+export declare function showIndexes(config: Config, table: string, profile?: string, format?: 'json' | 'table' | 'toon'): Promise<IndexResult>;
+export declare function explainQuery(config: Config, query: string, profile?: string, format?: 'json' | 'table' | 'toon'): Promise<ExplainResult>;
 export declare function testDirectConnection(profile: DatabaseProfile): Promise<ConnectionTestResult>;
-/**
- * Close all connections
- */
 export declare function closeConnections(): Promise<void>;

package/dist/mysql/mysql-client.js

@@ -1,127 +1,70 @@
-import { readConfig } from '../config.js';
+import { createProfileManager } from '@hesed/plugin-lib';
 import { MySQLUtil } from './mysql-utils.js';
 let mysqlUtil = null;
 let cachedConfig = null;
-let cachedConfigDir;
-/**
- * Set the config directory for the singleton client
- * @param dir - Oclif config directory path
- */
-export function setConfigDir(dir) {
-    cachedConfigDir = dir;
-}
-/**
- * Initialize (or return cached) MySQLUtil
- */
-async function initMySQL() {
+const DEFAULT_SAFETY_CONFIG = {
+    blacklistedOperations: ['DROP DATABASE'],
+    defaultLimit: 100,
+    requireConfirmationFor: ['DELETE', 'UPDATE', 'DROP', 'TRUNCATE', 'ALTER'],
+};
+async function initMySQL(config) {
     if (mysqlUtil)
         return mysqlUtil;
-    if (!cachedConfigDir) {
-        throw new Error('MySQL client not initialized. Call setConfigDir() before running commands.');
+    const pm = createProfileManager(config);
+    const profiles = await pm.readProfiles();
+    if (!profiles) {
+        throw new Error(`No profile found.`);
     }
-    const jsonConfig = await readConfig(cachedConfigDir, console.error);
-    if (!jsonConfig) {
-        throw new Error('Missing connection config. Run "mq mysql auth add" to create a config.');
+    const defaultProfile = await pm.getDefaultProfile();
+    if (!defaultProfile) {
+        throw new Error(`Missing default profile.`);
     }
     cachedConfig = {
         defaultFormat: 'table',
-        defaultProfile: jsonConfig.defaultProfile,
-        profiles: jsonConfig.profiles,
-        safety: {
-            blacklistedOperations: ['DROP DATABASE'],
-            defaultLimit: 100,
-            requireConfirmationFor: ['DELETE', 'UPDATE', 'DROP', 'TRUNCATE', 'ALTER'],
-        },
+        defaultProfile,
+        profiles,
+        safety: DEFAULT_SAFETY_CONFIG,
     };
     mysqlUtil = new MySQLUtil(cachedConfig);
     return mysqlUtil;
 }
-/**
- * Get the loaded MySQL config, initializing if needed
- */
-export async function getMySQLConfig() {
-    if (!cachedConfig) {
-        await initMySQL();
-    }
-    return cachedConfig;
-}
-/**
- * Execute SQL query
- * @param query - SQL query to execute
- * @param profile - Database profile name
- * @param format - Output format
- * @param skipConfirmation - Skip confirmation for destructive operations
- */
-export async function executeQuery(query, profile, format = 'table', skipConfirmation = false) {
-    return (await initMySQL()).executeQuery(profile, query, format, skipConfirmation);
+// eslint-disable-next-line max-params
+export async function executeQuery(config, query, profile, format = 'table', skipConfirmation = false) {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initMySQL(config)).executeQuery(profileName, query, format, skipConfirmation);
 }
-/**
- * List all databases
- * @param profile - Database profile name
- */
-export async function listDatabases(profile) {
-    return (await initMySQL()).listDatabases(profile);
+export async function listDatabases(config, profile) {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initMySQL(config)).listDatabases(profileName);
 }
-/**
- * List all tables in current database
- * @param profile - Database profile name
- */
-export async function listTables(profile) {
-    return (await initMySQL()).listTables(profile);
+export async function listTables(config, profile) {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initMySQL(config)).listTables(profileName);
 }
-/**
- * Describe table structure
- * @param profile - Database profile name
- * @param table - Table name
- * @param format - Output format
- */
-export async function describeTable(profile, table, format = 'table') {
-    return (await initMySQL()).describeTable(profile, table, format);
+export async function describeTable(config, table, profile, format = 'table') {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initMySQL(config)).describeTable(profileName, table, format);
 }
-/**
- * Show table indexes
- * @param profile - Database profile name
- * @param table - Table name
- * @param format - Output format
- */
-export async function showIndexes(profile, table, format = 'table') {
-    return (await initMySQL()).showIndexes(profile, table, format);
+export async function showIndexes(config, table, profile, format = 'table') {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initMySQL(config)).showIndexes(profileName, table, format);
 }
-/**
- * Explain query execution plan
- * @param profile - Database profile name
- * @param query - SQL query to explain
- * @param format - Output format
- */
-export async function explainQuery(profile, query, format = 'table') {
-    return (await initMySQL()).explainQuery(profile, query, format);
+export async function explainQuery(config, query, profile, format = 'table') {
+    const profileName = profile ?? cachedConfig?.defaultProfile ?? 'default';
+    return (await initMySQL(config)).explainQuery(profileName, query, format);
 }
-/**
- * Test a connection directly with profile options (without loading JSON config)
- * @param profile - Database connection profile options
- */
 export async function testDirectConnection(profile) {
-    const tempConfig = {
+    const testConfig = {
         defaultFormat: 'table',
-        defaultProfile: '_auth',
-        profiles: { _auth: profile },
-        safety: {
-            blacklistedOperations: [],
-            defaultLimit: 100,
-            requireConfirmationFor: [],
-        },
+        defaultProfile: 'default',
+        profiles: { default: profile },
+        safety: DEFAULT_SAFETY_CONFIG,
     };
-    const tempUtil = new MySQLUtil(tempConfig);
-    try {
-        return await tempUtil.testConnection('_auth');
-    }
-    finally {
-        await tempUtil.closeAll();
-    }
+    const util = new MySQLUtil(testConfig);
+    const result = await util.testConnection('default');
+    await util.closeAll();
+    return result;
 }
-/**
- * Close all connections
- */
 export async function closeConnections() {
     if (mysqlUtil) {
         await mysqlUtil.closeAll();

package/dist/mysql/mysql-utils.d.ts

@@ -1,68 +1,18 @@
-import type { FieldPacket, RowDataPacket } from 'mysql2/promise';
 import type { MySQLConfig } from './config-loader.js';
 import type { ConnectionTestResult, DatabaseListResult, DatabaseUtil, ExplainResult, IndexResult, OutputFormat, QueryResult, TableListResult, TableStructureResult } from './database.js';
-/**
- * MySQL Database Utility
- * Provides core database operations with safety validation and formatting
- */
 export declare class MySQLUtil implements DatabaseUtil {
     private config;
-    private connectionPool;
+    private connections;
     constructor(config: MySQLConfig);
-    /**
-     * Close all connections
-     */
     closeAll(): Promise<void>;
-    /**
-     * Describe table structure
-     */
     describeTable(profileName: string, table: string, format?: 'json' | 'table' | 'toon'): Promise<TableStructureResult>;
-    /**
-     * Validate and execute a SQL query
-     */
     executeQuery(profileName: string, query: string, format?: OutputFormat, skipConfirmation?: boolean): Promise<QueryResult>;
-    /**
-     * Explain query execution plan
-     */
     explainQuery(profileName: string, query: string, format?: 'json' | 'table' | 'toon'): Promise<ExplainResult>;
-    /**
-     * Format query results as CSV
-     */
-    formatAsCsv(rows: RowDataPacket[], fields: FieldPacket[]): string;
-    /**
-     * Format query results as JSON
-     */
-    formatAsJson(rows: RowDataPacket[]): string;
-    /**
-     * Format query results as table
-     */
-    formatAsTable(rows: RowDataPacket[], fields: FieldPacket[]): string;
-    /**
-     * Format query results as TOON
-     */
-    formatAsToon(rows: RowDataPacket[]): string;
-    /**
-     * List all databases
-     */
     listDatabases(profileName: string): Promise<DatabaseListResult>;
-    /**
-     * List all tables in current database
-     */
     listTables(profileName: string): Promise<TableListResult>;
-    /**
-     * Show table indexes
-     */
     showIndexes(profileName: string, table: string, format?: 'json' | 'table' | 'toon'): Promise<IndexResult>;
-    /**
-     * Test database connection
-     */
     testConnection(profileName: string): Promise<ConnectionTestResult>;
-    /**
-     * Format rows for SELECT/SHOW/DESCRIBE/EXPLAIN query result
-     */
+    private formatRows;
     private formatSelectResult;
-    /**
-     * Get or create MySQL connection for a profile
-     */
     private getConnection;
 }