feat: SQL integration management (#24)

Author: jankuca

build/esbuild/build.ts

@@ -343,6 +343,11 @@ async function buildAll() {
             path.join(extensionFolder, 'src', 'webviews', 'webview-side', 'data-explorer', 'index.tsx'),
             path.join(extensionFolder, 'dist', 'webviews', 'webview-side', 'viewers', 'dataExplorer.js'),
             { target: 'web', watch: watchAll }
+        ),
+        build(
+            path.join(extensionFolder, 'src', 'webviews', 'webview-side', 'integrations', 'index.tsx'),
+            path.join(extensionFolder, 'dist', 'webviews', 'webview-side', 'integrations', 'index.js'),
+            { target: 'web', watch: watchAll }
         )
     );
 

package.json

@@ -85,6 +85,12 @@
                 "category": "Deepnote",
                 "icon": "$(reveal)"
             },
+            {
+                "command": "deepnote.manageIntegrations",
+                "title": "%deepnote.commands.manageIntegrations.title%",
+                "category": "Deepnote",
+                "icon": "$(plug)"
+            },
             {
                 "command": "dataScience.ClearCache",
                 "title": "%jupyter.command.dataScience.clearCache.title%",
@@ -707,6 +713,11 @@
                 }
             ],
             "notebook/toolbar": [
+                {
+                    "command": "deepnote.manageIntegrations",
+                    "group": "navigation@0",
+                    "when": "notebookType == 'deepnote'"
+                },
                 {
                     "command": "jupyter.restartkernel",
                     "group": "navigation/execute@5",

package.nls.json

@@ -249,6 +249,7 @@
     "deepnote.commands.openNotebook.title": "Open Notebook",
     "deepnote.commands.openFile.title": "Open File",
     "deepnote.commands.revealInExplorer.title": "Reveal in Explorer",
+    "deepnote.commands.manageIntegrations.title": "Manage Integrations",
     "deepnote.views.explorer.name": "Explorer",
     "deepnote.command.selectNotebook.title": "Select Notebook"
 }

src/notebooks/deepnote/deepnoteActivationService.ts

@@ -5,6 +5,7 @@ import { IExtensionContext } from '../../platform/common/types';
 import { IDeepnoteNotebookManager } from '../types';
 import { DeepnoteNotebookSerializer } from './deepnoteSerializer';
 import { DeepnoteExplorerView } from './deepnoteExplorerView';
+import { IIntegrationManager } from './integrations/types';
 
 /**
  * Service responsible for activating and configuring Deepnote notebook support in VS Code.
@@ -13,12 +14,18 @@ import { DeepnoteExplorerView } from './deepnoteExplorerView';
 @injectable()
 export class DeepnoteActivationService implements IExtensionSyncActivationService {
     private explorerView: DeepnoteExplorerView;
+
+    private integrationManager: IIntegrationManager;
+
     private serializer: DeepnoteNotebookSerializer;
 
     constructor(
         @inject(IExtensionContext) private extensionContext: IExtensionContext,
-        @inject(IDeepnoteNotebookManager) private readonly notebookManager: IDeepnoteNotebookManager
-    ) {}
+        @inject(IDeepnoteNotebookManager) private readonly notebookManager: IDeepnoteNotebookManager,
+        @inject(IIntegrationManager) integrationManager: IIntegrationManager
+    ) {
+        this.integrationManager = integrationManager;
+    }
 
     /**
      * Activates Deepnote support by registering serializers and commands.
@@ -31,5 +38,6 @@ export class DeepnoteActivationService implements IExtensionSyncActivationServic
         this.extensionContext.subscriptions.push(workspace.registerNotebookSerializer('deepnote', this.serializer));
 
         this.explorerView.activate();
+        this.integrationManager.activate();
     }
 }

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

@@ -3,19 +3,26 @@ import { assert } from 'chai';
 import { DeepnoteActivationService } from './deepnoteActivationService';
 import { DeepnoteNotebookManager } from './deepnoteNotebookManager';
 import { IExtensionContext } from '../../platform/common/types';
+import { IIntegrationManager } from './integrations/types';
 
 suite('DeepnoteActivationService', () => {
     let activationService: DeepnoteActivationService;
     let mockExtensionContext: IExtensionContext;
     let manager: DeepnoteNotebookManager;
+    let mockIntegrationManager: IIntegrationManager;
 
     setup(() => {
         mockExtensionContext = {
             subscriptions: []
         } as any;
 
         manager = new DeepnoteNotebookManager();
-        activationService = new DeepnoteActivationService(mockExtensionContext, manager);
+        mockIntegrationManager = {
+            activate: () => {
+                return;
+            }
+        };
+        activationService = new DeepnoteActivationService(mockExtensionContext, manager, mockIntegrationManager);
     });
 
     suite('constructor', () => {
@@ -75,8 +82,18 @@ suite('DeepnoteActivationService', () => {
 
             const manager1 = new DeepnoteNotebookManager();
             const manager2 = new DeepnoteNotebookManager();
-            const service1 = new DeepnoteActivationService(context1, manager1);
-            const service2 = new DeepnoteActivationService(context2, manager2);
+            const mockIntegrationManager1: IIntegrationManager = {
+                activate: () => {
+                    return;
+                }
+            };
+            const mockIntegrationManager2: IIntegrationManager = {
+                activate: () => {
+                    return;
+                }
+            };
+            const service1 = new DeepnoteActivationService(context1, manager1, mockIntegrationManager1);
+            const service2 = new DeepnoteActivationService(context2, manager2, mockIntegrationManager2);
 
             // Verify each service has its own context
             assert.strictEqual((service1 as any).extensionContext, context1);
@@ -101,8 +118,18 @@ suite('DeepnoteActivationService', () => {
 
             const manager1 = new DeepnoteNotebookManager();
             const manager2 = new DeepnoteNotebookManager();
-            new DeepnoteActivationService(context1, manager1);
-            new DeepnoteActivationService(context2, manager2);
+            const mockIntegrationManager1: IIntegrationManager = {
+                activate: () => {
+                    return;
+                }
+            };
+            const mockIntegrationManager2: IIntegrationManager = {
+                activate: () => {
+                    return;
+                }
+            };
+            new DeepnoteActivationService(context1, manager1, mockIntegrationManager1);
+            new DeepnoteActivationService(context2, manager2, mockIntegrationManager2);
 
             assert.strictEqual(context1.subscriptions.length, 0);
             assert.strictEqual(context2.subscriptions.length, 1);

src/notebooks/deepnote/deepnoteSerializer.ts

@@ -2,6 +2,7 @@ import { injectable, inject } from 'inversify';
 import { l10n, type CancellationToken, type NotebookData, type NotebookSerializer, workspace } from 'vscode';
 import * as yaml from 'js-yaml';
 
+import { logger } from '../../platform/logging';
 import { IDeepnoteNotebookManager } from '../types';
 import type { DeepnoteProject } from './deepnoteTypes';
 import { DeepnoteDataConverter } from './deepnoteDataConverter';
@@ -35,7 +36,7 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
      * @returns Promise resolving to notebook data
      */
     async deserializeNotebook(content: Uint8Array, token: CancellationToken): Promise<NotebookData> {
-        console.log('Deserializing Deepnote notebook');
+        logger.debug('DeepnoteSerializer: Deserializing Deepnote notebook');
 
         if (token?.isCancellationRequested) {
             throw new Error('Serialization cancelled');
@@ -52,7 +53,7 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
             const projectId = deepnoteProject.project.id;
             const notebookId = this.findCurrentNotebookId(projectId);
 
-            console.log(`Selected notebook ID: ${notebookId}.`);
+            logger.debug(`DeepnoteSerializer: Project ID: ${projectId}, Selected notebook ID: ${notebookId}`);
 
             const selectedNotebook = notebookId
                 ? deepnoteProject.project.notebooks.find((nb) => nb.id === notebookId)
@@ -64,9 +65,10 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
 
             const cells = this.converter.convertBlocksToCells(selectedNotebook.blocks);
 
-            console.log(`Converted ${cells.length} cells from notebook blocks.`);
+            logger.debug(`DeepnoteSerializer: Converted ${cells.length} cells from notebook blocks`);
 
             this.notebookManager.storeOriginalProject(deepnoteProject.project.id, deepnoteProject, selectedNotebook.id);
+            logger.debug(`DeepnoteSerializer: Stored project ${projectId} in notebook manager`);
 
             return {
                 cells,
@@ -81,7 +83,7 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
                 }
             };
         } catch (error) {
-            console.error('Error deserializing Deepnote notebook:', error);
+            logger.error('DeepnoteSerializer: Error deserializing Deepnote notebook', error);
 
             throw new Error(
                 `Failed to parse Deepnote file: ${error instanceof Error ? error.message : 'Unknown error'}`
@@ -148,7 +150,7 @@ export class DeepnoteNotebookSerializer implements NotebookSerializer {
 
             return new TextEncoder().encode(yamlString);
         } catch (error) {
-            console.error('Error serializing Deepnote notebook:', error);
+            logger.error('DeepnoteSerializer: Error serializing Deepnote notebook', error);
             throw new Error(
                 `Failed to save Deepnote file: ${error instanceof Error ? error.message : 'Unknown error'}`
             );

src/notebooks/deepnote/integrations/integrationDetector.ts

@@ -0,0 +1,75 @@
+import { inject, injectable } from 'inversify';
+
+import { logger } from '../../../platform/logging';
+import { IDeepnoteNotebookManager } from '../../types';
+import { IntegrationStatus, IntegrationWithStatus } from './integrationTypes';
+import { IIntegrationDetector, IIntegrationStorage } from './types';
+import { BlockWithIntegration, scanBlocksForIntegrations } from './integrationUtils';
+
+/**
+ * Service for detecting integrations used in Deepnote notebooks
+ */
+@injectable()
+export class IntegrationDetector implements IIntegrationDetector {
+    constructor(
+        @inject(IIntegrationStorage) private readonly integrationStorage: IIntegrationStorage,
+        @inject(IDeepnoteNotebookManager) private readonly notebookManager: IDeepnoteNotebookManager
+    ) {}
+
+    /**
+     * Detect all integrations used in the given project
+     */
+    async detectIntegrations(projectId: string): Promise<Map<string, IntegrationWithStatus>> {
+        // Get the project
+        const project = this.notebookManager.getOriginalProject(projectId);
+        if (!project) {
+            logger.warn(
+                `IntegrationDetector: No project found for ID: ${projectId}. The project may not have been loaded yet.`
+            );
+            return new Map();
+        }
+
+        logger.debug(
+            `IntegrationDetector: Scanning project ${projectId} with ${project.project.notebooks.length} notebooks`
+        );
+
+        // Collect all blocks with SQL integration metadata from all notebooks
+        const blocksWithIntegrations: BlockWithIntegration[] = [];
+        for (const notebook of project.project.notebooks) {
+            logger.trace(`IntegrationDetector: Scanning notebook ${notebook.id} with ${notebook.blocks.length} blocks`);
+
+            for (const block of notebook.blocks) {
+                // Check if this is a code block with SQL integration metadata
+                if (block.type === 'code' && block.metadata?.sql_integration_id) {
+                    blocksWithIntegrations.push({
+                        id: block.id,
+                        sql_integration_id: block.metadata.sql_integration_id
+                    });
+                } else if (block.type === 'code') {
+                    logger.trace(
+                        `IntegrationDetector: Block ${block.id} has no sql_integration_id. Metadata:`,
+                        block.metadata
+                    );
+                }
+            }
+        }
+
+        // Use the shared utility to scan blocks and build the status map
+        return scanBlocksForIntegrations(blocksWithIntegrations, this.integrationStorage, 'IntegrationDetector');
+    }
+
+    /**
+     * Check if a project has any unconfigured integrations
+     */
+    async hasUnconfiguredIntegrations(projectId: string): Promise<boolean> {
+        const integrations = await this.detectIntegrations(projectId);
+
+        for (const integration of integrations.values()) {
+            if (integration.status === IntegrationStatus.Disconnected) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}