Verwalten Sie die TOML-Konfiguration über die VSCode-Erweiterung – DBChat Teil 8

Shrijith Venkatrama, Gründer von Hexmos, entwickelt LiveAPI, ein superpraktisches Tool, das Engineering-Workflows rationalisiert, indem es in nur wenigen Minuten eine großartige API-Dokumentation aus Ihrem Code generiert.

In dieser Tutorialreihe baue ich mir DBChat – ein einfaches Tool zum Erkunden und Verbessern von Datenbanken mithilfe von KI-Chat.

Weiteren Kontext finden Sie im vorherigen Artikel:

1. DBChat erstellen – Erkunden und verbessern Sie Ihre Datenbank mit einfachem Chat (Teil 1)
2. DBChat: Einführung eines Spielzeug-REPL in Golang (Teil 2)
3. DBChat Teil 3 – Konfigurieren, Verbinden und Sichern der Datenbank
4. Chatten Sie mit Ihrer Datenbank mit DBChat und Gemini (Teil 4)
5. Sprachserverprotokoll – Erstellen von DBChat (Teil 5)
6. Erstellen einer DBChat VSCode-Erweiterung – Ping-Pong-Interaktion mit LSP-Backend (Teil 6)
7. Starten der VSCode-Erweiterungs-Benutzeroberfläche für DBChat (Teil 7)

Erstellen Sie eine TOML-Verbindungsmanager-Benutzeroberfläche für DBChat in der VSCode-Erweiterung

Im vorherigen Artikel haben wir ein Framework für eine einfache Chat-Benutzeroberfläche und ein Datenbankverbindungsformular in der DBChat VSCode-Erweiterung erstellt.

In diesem Beitrag werde ich zeigen, wie die DBChat-Erweiterung den Abschnitt [connections] der Konfigurationsdatei ~/.dbchat.toml manipuliert, um Einträge hinzuzufügen/aktualisieren/löschen.

Um Ihren Speicher aufzufrischen, sollte die Konfigurationsdatei die folgende Struktur haben:

<code># DBChat 示例配置文件
# 将此文件复制到 ~/.dbchat.toml 并根据需要修改

[connections]
# 格式：name = "connection_string"
local = "postgresql://postgres:postgres@localhost:5432/postgres"
liveapi = "postgresql://user:pwd@ip:5432/db_name" 

[llm]
gemini_key = "the_key"</code>

Ergebnisse

DBChat-Verbindungsliste:

DBChat Verbindung hinzufügen/bearbeiten:

Für Änderungen und Aktualisierungen verfügen wir außerdem über eine Bestätigungsabfrage, um Fehler zu vermeiden.

Verbindungsanforderung zur Erstellung bearbeiten

Installieren Sie zunächst die toml-Erweiterung:

<code> npm install @iarna/toml</code>

Wir bekommen einige neue Importe:

<code>import * as fs from 'fs/promises';
import * as path from 'path';
import * as os from 'os';
import * as TOML from '@iarna/toml';</code>

Die Schlüsselstruktur ist ein Nachrichtenhandler, der Ereignisse für alle drei Vorgänge empfängt:

<code>        const messageHandler = this._view.webview.onDidReceiveMessage(
            async (message) => {
                console.log('Received message:', message);
                switch (message.command) {
                    case 'saveConnection':
                        console.log('Processing saveConnection command');
                        const success = await this._saveConnection(message.name, message.connectionString);
                        if (success) {
                            console.log('Connection saved successfully, closing form');
                            this._showingConnectionForm = false;
                            this._updateView();
                        } else {
                            console.log('Connection not saved, keeping form open');
                        }
                        break;
                    case 'cancel':
                        console.log('Processing cancel command');
                        this._showingConnectionForm = false;
                        this._updateView();
                        break;
                    case 'editConnection':
                        this._showingConnectionForm = true;
                        this._editingConnection = message.name;
                        // First update the view to show the form
                        await this._updateView();
                        // Then send the prefill message after a short delay to ensure the form exists
                        setTimeout(() => {
                            this._view.webview.postMessage({ 
                                command: 'prefillForm', 
                                name: message.name, 
                                connectionString: message.connectionString 
                            });
                        }, 100);
                        break;
                    case 'deleteConnection':
                        const choice = await vscode.window.showWarningMessage(
                            `Are you sure you want to delete connection "${message.name}"?`,
                            'Yes',
                            'No'
                        );
                        if (choice === 'Yes') {
                            const deleted = await this._deleteConnection(message.name);
                            if (deleted) {
                                await this._updateView();  // Update view after successful deletion
                                vscode.window.showInformationMessage(`Connection "${message.name}" deleted successfully.`);
                            }
                        }
                        break;
                }
            }
        );

        // Add message handler to subscriptions for cleanup
        context.subscriptions.push(messageHandler);</code>

Eine Verbindung zu speichern ist einfach:

<code>    private async _saveConnection(name: string, connectionString: string): Promise<boolean> {
        console.log('Starting _saveConnection with:', { name, connectionString });
        try {
            const configPath = path.join(os.homedir(), 'dbchat.toml');
            console.log('Config path:', configPath);

            let config: any = {
                connections: {},
                llm: {}
            };
            console.log('Initial config structure:', config);

            // Read existing config if it exists
            try {
                console.log('Attempting to read existing config file...');
                const fileContent = await fs.readFile(configPath, 'utf-8');
                console.log('Existing file content:', fileContent);

                console.log('Parsing TOML content...');
                config = TOML.parse(fileContent);
                console.log('Parsed config:', config);

                // Ensure connections section exists
                config.connections = config.connections || {};
                console.log('Config after ensuring connections exist:', config);
            } catch (error: any) {
                console.log('Error reading config:', error);
                if (error.code !== 'ENOENT') {
                    console.error('Unexpected error reading config:', error);
                    throw error;
                }
                console.log('Config file does not exist, will create new one');
            }

            // Check if connection already exists
            if (config.connections[name]) {
                console.log(`Connection "${name}" already exists, showing confirmation dialog`);
                const choice = await vscode.window.showWarningMessage(
                    `Connection "${name}" already exists. Do you want to overwrite it?`,
                    'Yes',
                    'No'
                );
                console.log('User choice for overwrite:', choice);

                if (choice !== 'Yes') {
                    console.log('User declined to overwrite, returning false');
                    return false;
                }
            }

            // Update the connection
            config.connections[name] = connectionString;
            console.log('Updated config:', config);

            // Convert config to TOML and write back to file
            console.log('Converting config to TOML...');
            const tomlContent = TOML.stringify(config);
            console.log('Generated TOML content:', tomlContent);

            // Preserve the header comments
            const finalContent = `# DBChat Sample Configuration File
# Copy this file to ~/.dbchat.toml and modify as needed

${tomlContent}`;
            console.log('Final content to write:', finalContent);

            console.log('Writing to file...');
            await fs.writeFile(configPath, finalContent, 'utf-8');
            console.log('File written successfully');

            // Update view immediately after successful file write
            this._showingConnectionForm = false;
            console.log('Form hidden, updating view');
            this._updateView();

            await vscode.window.showInformationMessage(`Connection "${name}" saved successfully!`, { modal: false });
            return true;
        } catch (error) {
            console.error('Error in _saveConnection:', error);
            if (error instanceof Error) {
                console.error('Error stack:', error.stack);
            }
            await vscode.window.showErrorMessage(`Failed to save connection: ${error}`);
            return false;
        }
    }
</boolean></code>

Verbindungen auflisten

<code>    private async _getConnections(): Promise {
        try {
            const configPath = path.join(os.homedir(), 'dbchat.toml');
            const fileContent = await fs.readFile(configPath, 'utf-8');
            const config = TOML.parse(fileContent);
            return config.connections || {};
        } catch (error) {
            console.error('Error reading connections:', error);
            return {};
        }
    }</code>

Verbindung löschen

<code>    private async _deleteConnection(name: string): Promise<boolean> {
        try {
            const configPath = path.join(os.homedir(), 'dbchat.toml');
            const fileContent = await fs.readFile(configPath, 'utf-8');
            const config = TOML.parse(fileContent);

            if (!config.connections || !config.connections[name]) {
                await vscode.window.showErrorMessage(`Connection "${name}" not found.`);
                return false;
            }

            delete config.connections[name];

            const tomlContent = TOML.stringify(config);
            const finalContent = `# DBChat Sample Configuration File
# Copy this file to ~/.dbchat.toml and modify as needed

${tomlContent}`;

            await fs.writeFile(configPath, finalContent, 'utf-8');
            // Show message after file operations are complete
            vscode.window.showInformationMessage(`Connection "${name}" deleted successfully.`);
            return true;
        } catch (error) {
            console.error('Error deleting connection:', error);
            vscode.window.showErrorMessage(`Failed to delete connection: ${error}`);
            return false;
        }
    }
</boolean></code>

Das ist alles für diesen Beitrag. Durch diese Struktur implementieren wir eine grundlegende Datenbankverbindungsliste sowie Vorgänge zum Hinzufügen, Löschen und Aktualisieren.

Nächste Schritte

Da wir über einen grundlegenden Datenbankkonfigurationsmechanismus verfügen, werden wir als Nächstes daran arbeiten, die Möglichkeit zu ermöglichen, eine Verbindung zu bestimmten Konfigurationen herzustellen, Schemata abzurufen, mit der Datenbank zu chatten usw. – mithilfe von Golang LSP.

Das obige ist der detaillierte Inhalt vonVerwalten Sie die TOML-Konfiguration über die VSCode-Erweiterung – DBChat Teil 8. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!