feat: expose error message from failed project saving

Author: jankuca

src/notebooks/deepnote/deepnoteNotebookManager.ts

@@ -1,6 +1,6 @@
 import { injectable } from 'inversify';
 
-import { IDeepnoteNotebookManager } from '../types';
+import { IDeepnoteNotebookManager, ProjectIntegration } from '../types';
 import type { DeepnoteProject } from './deepnoteTypes';
 
 /**
@@ -78,17 +78,16 @@ export class DeepnoteNotebookManager implements IDeepnoteNotebookManager {
     /**
      * Updates the integrations list in the project data.
      * This modifies the stored project to reflect changes in configured integrations.
-     * @param projectId Project identifier
-     * @param integrations Array of integration metadata to store in the project
+     *
+     * @param projectId - Project identifier
+     * @param integrations - Array of integration metadata to store in the project
+     * @returns `true` if the project was found and updated successfully, `false` if the project does not exist
      */
-    updateProjectIntegrations(
-        projectId: string,
-        integrations: Array<{ id: string; name: string; type: string }>
-    ): void {
+    updateProjectIntegrations(projectId: string, integrations: ProjectIntegration[]): boolean {
         const project = this.originalProjects.get(projectId);
 
         if (!project) {
-            return;
+            return false;
         }
 
         const updatedProject = JSON.parse(JSON.stringify(project)) as DeepnoteProject;
@@ -99,6 +98,8 @@ export class DeepnoteNotebookManager implements IDeepnoteNotebookManager {
         if (currentNotebookId) {
             this.storeOriginalProject(projectId, updatedProject, currentNotebookId);
         }
+
+        return true;
     }
 
     /**

src/notebooks/deepnote/deepnoteNotebookManager.unit.test.ts

@@ -184,21 +184,23 @@ suite('DeepnoteNotebookManager', () => {
     });
 
     suite('updateProjectIntegrations', () => {
-        test('should update integrations list for existing project', () => {
+        test('should update integrations list for existing project and return true', () => {
             manager.storeOriginalProject('project-123', mockProject, 'notebook-456');
 
             const integrations = [
                 { id: 'int-1', name: 'PostgreSQL', type: 'pgsql' },
                 { id: 'int-2', name: 'BigQuery', type: 'big-query' }
             ];
 
-            manager.updateProjectIntegrations('project-123', integrations);
+            const result = manager.updateProjectIntegrations('project-123', integrations);
+
+            assert.strictEqual(result, true);
 
             const updatedProject = manager.getOriginalProject('project-123');
             assert.deepStrictEqual(updatedProject?.project.integrations, integrations);
         });
 
-        test('should replace existing integrations list', () => {
+        test('should replace existing integrations list and return true', () => {
             const projectWithIntegrations: DeepnoteProject = {
                 ...mockProject,
                 project: {
@@ -214,13 +216,15 @@ suite('DeepnoteNotebookManager', () => {
                 { id: 'new-int-2', name: 'New Integration 2', type: 'big-query' }
             ];
 
-            manager.updateProjectIntegrations('project-123', newIntegrations);
+            const result = manager.updateProjectIntegrations('project-123', newIntegrations);
+
+            assert.strictEqual(result, true);
 
             const updatedProject = manager.getOriginalProject('project-123');
             assert.deepStrictEqual(updatedProject?.project.integrations, newIntegrations);
         });
 
-        test('should handle empty integrations array', () => {
+        test('should handle empty integrations array and return true', () => {
             const projectWithIntegrations: DeepnoteProject = {
                 ...mockProject,
                 project: {
@@ -231,26 +235,33 @@ suite('DeepnoteNotebookManager', () => {
 
             manager.storeOriginalProject('project-123', projectWithIntegrations, 'notebook-456');
 
-            manager.updateProjectIntegrations('project-123', []);
+            const result = manager.updateProjectIntegrations('project-123', []);
+
+            assert.strictEqual(result, true);
 
             const updatedProject = manager.getOriginalProject('project-123');
             assert.deepStrictEqual(updatedProject?.project.integrations, []);
         });
 
-        test('should do nothing for unknown project', () => {
-            // Should not throw an error
-            manager.updateProjectIntegrations('unknown-project', [{ id: 'int-1', name: 'Integration', type: 'pgsql' }]);
+        test('should return false for unknown project', () => {
+            const result = manager.updateProjectIntegrations('unknown-project', [
+                { id: 'int-1', name: 'Integration', type: 'pgsql' }
+            ]);
+
+            assert.strictEqual(result, false);
 
             const project = manager.getOriginalProject('unknown-project');
             assert.strictEqual(project, undefined);
         });
 
-        test('should preserve other project properties', () => {
+        test('should preserve other project properties and return true', () => {
             manager.storeOriginalProject('project-123', mockProject, 'notebook-456');
 
             const integrations = [{ id: 'int-1', name: 'PostgreSQL', type: 'pgsql' }];
 
-            manager.updateProjectIntegrations('project-123', integrations);
+            const result = manager.updateProjectIntegrations('project-123', integrations);
+
+            assert.strictEqual(result, true);
 
             const updatedProject = manager.getOriginalProject('project-123');
             assert.strictEqual(updatedProject?.project.id, mockProject.project.id);

src/notebooks/deepnote/integrations/integrationWebview.ts

@@ -5,7 +5,7 @@ import { IExtensionContext } from '../../../platform/common/types';
 import * as localize from '../../../platform/common/utils/localize';
 import { logger } from '../../../platform/logging';
 import { LocalizedMessages, SharedMessages } from '../../../messageTypes';
-import { IDeepnoteNotebookManager } from '../../types';
+import { IDeepnoteNotebookManager, ProjectIntegration } from '../../types';
 import { IIntegrationStorage, IIntegrationWebviewProvider } from './types';
 import {
     INTEGRATION_TYPE_TO_DEEPNOTE,
@@ -311,7 +311,7 @@ export class IntegrationWebviewProvider implements IIntegrationWebviewProvider {
         }
 
         // Build the integrations list from current integrations
-        const projectIntegrations = Array.from(this.integrations.entries())
+        const projectIntegrations: ProjectIntegration[] = Array.from(this.integrations.entries())
             .map(([id, integration]) => {
                 // Get the integration type from config or integration metadata
                 const type = integration.config?.type || integration.integrationType;
@@ -333,14 +333,23 @@ export class IntegrationWebviewProvider implements IIntegrationWebviewProvider {
                     type: deepnoteType
                 };
             })
-            .filter((integration): integration is { id: string; name: string; type: string } => integration !== null);
+            .filter((integration): integration is ProjectIntegration => integration !== null);
 
         logger.debug(
             `IntegrationWebviewProvider: Updating project ${this.projectId} with ${projectIntegrations.length} integrations`
         );
 
         // Update the project in the notebook manager
-        this.notebookManager.updateProjectIntegrations(this.projectId, projectIntegrations);
+        const success = this.notebookManager.updateProjectIntegrations(this.projectId, projectIntegrations);
+
+        if (!success) {
+            logger.error(
+                `IntegrationWebviewProvider: Failed to update integrations for project ${this.projectId} - project not found`
+            );
+            void window.showErrorMessage(
+                l10n.t('Failed to update integrations: project not found. Please reopen the notebook and try again.')
+            );
+        }
     }
 
     /**

src/notebooks/types.ts

@@ -25,6 +25,15 @@ export interface INotebookPythonEnvironmentService {
     getPythonEnvironment(uri: Uri): EnvironmentPath | undefined;
 }
 
+/**
+ * Represents a Deepnote project integration with basic metadata.
+ */
+export interface ProjectIntegration {
+    id: string;
+    name: string;
+    type: string;
+}
+
 export const IDeepnoteNotebookManager = Symbol('IDeepnoteNotebookManager');
 export interface IDeepnoteNotebookManager {
     getCurrentNotebookId(projectId: string): string | undefined;
@@ -33,7 +42,17 @@ export interface IDeepnoteNotebookManager {
     selectNotebookForProject(projectId: string, notebookId: string): void;
     storeOriginalProject(projectId: string, project: DeepnoteProject, notebookId: string): void;
     updateCurrentNotebookId(projectId: string, notebookId: string): void;
-    updateProjectIntegrations(projectId: string, integrations: Array<{ id: string; name: string; type: string }>): void;
+
+    /**
+     * Updates the integrations list in the project data.
+     * This modifies the stored project to reflect changes in configured integrations.
+     *
+     * @param projectId - Project identifier
+     * @param integrations - Array of integration metadata to store in the project
+     * @returns `true` if the project was found and updated successfully, `false` if the project does not exist
+     */
+    updateProjectIntegrations(projectId: string, integrations: ProjectIntegration[]): boolean;
+
     hasInitNotebookBeenRun(projectId: string): boolean;
     markInitNotebookAsRun(projectId: string): void;
 }