feat: update changelog for version 0.19.13 and implement save prompt for unsaved changes in untitled queries

Author: jakubkozera

CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to the MS SQL Manager extension will be documented in this f
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.19.13] - 2026-05-29
+
+### Changed
+
+- **New Query — Now prompts to save unsaved changes on close**
+  - "New Query" (untitled queries) now open as VS Code untitled documents through the custom SQL editor, instead of raw webview panels.
+  - Closing an untitled query that has been edited now shows VS Code's native "Do you want to save the changes?" dialog with Save / Don't Save / Cancel options.
+  - Save triggers a Save As dialog to pick a `.sql` file location, then continues editing in the custom editor.
+  - Empty untitled queries (no content typed) can still be closed without a prompt.
+  - Auto-execute and query history info are preserved when opening untitled queries from tree commands.
+
 ## [0.19.12] - 2026-05-29
 
 ### Fixed

package.json

@@ -2,7 +2,7 @@
   "name": "ms-sql-manager",
   "displayName": "MS SQL Manager",
   "description": "Manage Microsoft SQL Server databases with connection management, schema browsing, and query execution.",
-  "version": "0.19.12",
+  "version": "0.19.13",
   "publisher": "jakubkozera",
   "icon": "ms-sql-manager.png",
   "sponsor": {

src/sqlEditorProvider.ts

@@ -22,6 +22,10 @@ export class SqlEditorProvider implements vscode.CustomTextEditorProvider {
     private sqlSnippets: any[] = [];
     // Schema cache instance
     private schemaCache: SchemaCache;
+    // Pending options for the next resolveCustomTextEditor call (auto-execute, history info)
+    private pendingEditorOptions: { autoExecute?: boolean; historyInfo?: Record<string, unknown> } | null = null;
+    // Counter for unique untitled query names
+    private untitledCounter = 0;
 
     constructor(
         private readonly context: vscode.ExtensionContext,
@@ -126,8 +130,22 @@ export class SqlEditorProvider implements vscode.CustomTextEditorProvider {
                     // Send initial connections list
                     this.updateConnectionsList(webviewPanel.webview);
 
-                    // Note: Auto-execute is now controlled by the newQuery command via triggerAutoExecute()
-                    // to give explicit control over when queries execute
+                    // Handle pending options (auto-execute, history info) for untitled queries
+                    // opened via openUntitledQuery → CustomTextEditorProvider path
+                    if (this.pendingEditorOptions) {
+                        const opts = this.pendingEditorOptions;
+                        this.pendingEditorOptions = null;
+
+                        if (opts.historyInfo) {
+                            webviewPanel.webview.postMessage({ type: 'historyInfo', ...opts.historyInfo });
+                        }
+
+                        if (opts.autoExecute && document.getText().trim()) {
+                            setTimeout(() => {
+                                webviewPanel.webview.postMessage({ type: 'autoExecuteQuery' });
+                            }, 200);
+                        }
+                    }
                     break;
 
                 case 'contentChanged':
@@ -1946,71 +1964,53 @@ COMMIT TRANSACTION;
     }
 
     /**
-     * Open an untitled SQL query webview panel (not backed by a file).
-     * When the user presses Ctrl+S the content is saved to a .sql file and
-     * re-opened in the normal CustomTextEditor.
+     * Open an untitled SQL query in the custom text editor.
+     * Uses VS Code's native untitled document support for proper dirty-state
+     * tracking and save prompts on close.
      */
     public async openUntitledQuery(
         connectionId: string,
         databaseName?: string,
         initialQuery?: string,
         autoExecute: boolean = false,
         historyInfo?: Record<string, unknown>
-    ): Promise<vscode.WebviewPanel> {
-        // Get connection config to determine base title
+    ): Promise<vscode.WebviewPanel | undefined> {
+        // Store connection preference so resolveCustomTextEditor picks it up
+        this.connectionProvider.setNextEditorPreferredDatabase(connectionId, databaseName || 'master');
+
+        // Store auto-execute and history info for the pending resolveCustomTextEditor call
+        if (autoExecute || historyInfo) {
+            this.pendingEditorOptions = { autoExecute, historyInfo };
+        }
+
+        // Build a meaningful title based on connection/database
         const config = this.connectionProvider.getConnectionConfig(connectionId);
         let baseTitle = 'Query';
         if (config) {
             if (config.connectionType === 'database') {
-                // Database connection - use connection name
                 baseTitle = `Query - ${config.name}`;
             } else {
-                // Server connection - use database name
                 baseTitle = databaseName ? `Query - ${databaseName}` : `Query - ${config.name}`;
             }
         }
 
-        // Find unique title (adds counter if needed)
-        const uniqueTitle = this.getUniqueUntitledTitle(baseTitle);
-        
-        const panel = vscode.window.createWebviewPanel(
-            'mssqlManager.sqlEditorUntitled',
-            uniqueTitle,
-            vscode.ViewColumn.One,
-            {
-                enableScripts: true,
-                retainContextWhenHidden: true,
-                localResourceRoots: [
-                    vscode.Uri.joinPath(this.context.extensionUri, 'webview'),
-                    vscode.Uri.joinPath(this.context.extensionUri, 'resources')
-                ]
-            }
-        );
-
-        // Set icon with light/dark theme variants
-        panel.iconPath = {
-            light: vscode.Uri.joinPath(this.context.extensionUri, 'resources', 'icons', 'database-light.svg'),
-            dark: vscode.Uri.joinPath(this.context.extensionUri, 'resources', 'icons', 'database-dark.svg')
-        };
-
-        // Track this panel for unique title management
-        this.untitledPanels.set(panel, baseTitle);
-
-        // In-memory content buffer
-        let currentContent = initialQuery || '';
-        const compositeId = databaseName ? `${connectionId}::${databaseName}` : connectionId;
+        // Create an untitled document with a named URI for a meaningful tab title
+        this.untitledCounter++;
+        const untitledUri = vscode.Uri.parse(`untitled:${baseTitle}${this.untitledCounter > 1 ? ` (${this.untitledCounter})` : ''}.sql`);
+        const doc = await vscode.workspace.openTextDocument(untitledUri);
 
-        // Track this webview like a regular editor
-        const syntheticUri = vscode.Uri.parse(`untitled:query-${Date.now()}`);
-        this.webviewToDocument.set(panel.webview, syntheticUri);
-        this.webviewSelectedConnection.set(panel.webview, compositeId);
+        // Set initial content if provided
+        if (initialQuery) {
+            const edit = new vscode.WorkspaceEdit();
+            edit.insert(doc.uri, new vscode.Position(0, 0), initialQuery);
+            await vscode.workspace.applyEdit(edit);
+        }
 
-        panel.webview.html = this.getReactHtmlForWebview(panel.webview);
+        // Open it with our custom SQL editor
+        await vscode.commands.executeCommand('vscode.openWith', doc.uri, SqlEditorProvider.viewType);
 
-        // Setup state for serialization/restoration
-        this.setupUntitledPanelHandlers(panel, connectionId, databaseName, initialQuery || '', autoExecute, historyInfo);
-        
-        return panel;
+        this.outputChannel.appendLine(`[SqlEditorProvider] Opened untitled query via CustomTextEditor for ${connectionId}::${databaseName || 'master'}`);
+        return undefined;
     }
 
     /**