migrate all components to the new database integration config format

Author: jankuca

src/notebooks/deepnote/integrations/integrationDetector.ts

@@ -2,14 +2,9 @@ import { inject, injectable } from 'inversify';
 
 import { logger } from '../../../platform/logging';
 import { IDeepnoteNotebookManager } from '../../types';
-import {
-    DATAFRAME_SQL_INTEGRATION_ID,
-    DEEPNOTE_TO_LEGACY_INTEGRATION_TYPE,
-    IntegrationStatus,
-    IntegrationWithStatus,
-    RawLegacyIntegrationType
-} from '../../../platform/notebooks/deepnote/integrationTypes';
+import { IntegrationStatus, IntegrationWithStatus } from '../../../platform/notebooks/deepnote/integrationTypes';
 import { IIntegrationDetector, IIntegrationStorage } from './types';
+import { DatabaseIntegrationType, databaseIntegrationTypes } from '@deepnote/database-integrations';
 
 /**
  * Service for detecting integrations used in Deepnote notebooks
@@ -40,40 +35,25 @@ export class IntegrationDetector implements IIntegrationDetector {
         const integrations = new Map<string, IntegrationWithStatus>();
 
         // Use the project's integrations field as the source of truth
-        const projectIntegrations = project.project.integrations || [];
+        const projectIntegrations = project.project.integrations?.slice() ?? [];
         logger.debug(`IntegrationDetector: Found ${projectIntegrations.length} integrations in project.integrations`);
 
         for (const projectIntegration of projectIntegrations) {
             const integrationId = projectIntegration.id;
-
-            // Skip the internal DuckDB integration
-            if (integrationId === DATAFRAME_SQL_INTEGRATION_ID) {
-                continue;
-            }
-
-            logger.debug(`IntegrationDetector: Found integration: ${integrationId} (${projectIntegration.type})`);
-
-            // Map the Deepnote integration type to our IntegrationType
-            const integrationType =
-                DEEPNOTE_TO_LEGACY_INTEGRATION_TYPE[projectIntegration.type as RawLegacyIntegrationType];
-
-            // Skip unknown integration types
-            if (!integrationType) {
-                logger.warn(
-                    `IntegrationDetector: Unknown integration type '${projectIntegration.type}' for integration ID '${integrationId}'. Skipping.`
-                );
+            const integrationType = projectIntegration.type;
+            if (!(databaseIntegrationTypes as readonly string[]).includes(integrationType)) {
+                logger.debug(`IntegrationDetector: Skipping unsupported integration type: ${integrationType}`);
                 continue;
             }
 
             // Check if the integration is configured
             const config = await this.integrationStorage.getIntegrationConfig(integrationId);
-
             const status: IntegrationWithStatus = {
-                config: config || null,
+                config: config ?? null,
                 status: config ? IntegrationStatus.Connected : IntegrationStatus.Disconnected,
                 // Include integration metadata from project for prefilling when config is null
                 integrationName: projectIntegration.name,
-                integrationType: integrationType
+                integrationType: integrationType as DatabaseIntegrationType
             };
 
             integrations.set(integrationId, status);

src/notebooks/deepnote/integrations/integrationManager.ts

@@ -1,19 +1,13 @@
 import { inject, injectable } from 'inversify';
-import { commands, l10n, NotebookDocument, window, workspace } from 'vscode';
+import { commands, l10n, window, workspace } from 'vscode';
 
 import { IExtensionContext } from '../../../platform/common/types';
 import { Commands } from '../../../platform/common/constants';
 import { logger } from '../../../platform/logging';
 import { IIntegrationDetector, IIntegrationManager, IIntegrationStorage, IIntegrationWebviewProvider } from './types';
-import {
-    DEEPNOTE_TO_LEGACY_INTEGRATION_TYPE,
-    IntegrationStatus,
-    LegacyIntegrationType,
-    IntegrationWithStatus,
-    RawLegacyIntegrationType
-} from '../../../platform/notebooks/deepnote/integrationTypes';
-import { BlockWithIntegration, scanBlocksForIntegrations } from './integrationUtils';
+import { IntegrationStatus } from '../../../platform/notebooks/deepnote/integrationTypes';
 import { IDeepnoteNotebookManager } from '../../types';
+import { DatabaseIntegrationType, databaseIntegrationTypes } from '@deepnote/database-integrations';
 
 /**
  * Manages integration UI and commands for Deepnote notebooks
@@ -143,14 +137,6 @@ export class IntegrationManager implements IIntegrationManager {
 
         // First try to detect integrations from the stored project
         let integrations = await this.integrationDetector.detectIntegrations(projectId);
-
-        // If no integrations found in stored project, scan cells directly
-        // This handles the case where the notebook was already open when the extension loaded
-        if (integrations.size === 0) {
-            logger.debug(`IntegrationManager: No integrations found in stored project, scanning cells directly`);
-            integrations = await this.detectIntegrationsFromCells(activeNotebook);
-        }
-
         logger.debug(`IntegrationManager: Found ${integrations.size} integrations`);
 
         // If a specific integration was requested (e.g., from status bar click),
@@ -164,21 +150,15 @@ export class IntegrationManager implements IIntegrationManager {
             const projectIntegration = project?.project.integrations?.find((i) => i.id === selectedIntegrationId);
 
             let integrationName: string | undefined;
-            let integrationType: LegacyIntegrationType | undefined;
+            let integrationType: DatabaseIntegrationType | undefined;
 
-            if (projectIntegration) {
+            // Validate that projectIntegration.type against supported types
+            if (
+                projectIntegration &&
+                (databaseIntegrationTypes as readonly string[]).includes(projectIntegration.type)
+            ) {
                 integrationName = projectIntegration.name;
-
-                // Validate that projectIntegration.type exists in the mapping before lookup
-                if (projectIntegration.type in DEEPNOTE_TO_LEGACY_INTEGRATION_TYPE) {
-                    // Map the Deepnote integration type to our IntegrationType
-                    integrationType =
-                        DEEPNOTE_TO_LEGACY_INTEGRATION_TYPE[projectIntegration.type as RawLegacyIntegrationType];
-                } else {
-                    logger.warn(
-                        `IntegrationManager: Unknown integration type '${projectIntegration.type}' for integration ID '${selectedIntegrationId}' in project '${projectId}'. Integration type will be undefined.`
-                    );
-                }
+                integrationType = projectIntegration.type as DatabaseIntegrationType;
             }
 
             integrations.set(selectedIntegrationId, {
@@ -197,35 +177,4 @@ export class IntegrationManager implements IIntegrationManager {
         // Show the webview with optional selected integration
         await this.webviewProvider.show(projectId, integrations, selectedIntegrationId);
     }
-
-    /**
-     * Detect integrations by scanning cells directly (fallback method)
-     * This is used when the project isn't stored in the notebook manager
-     */
-    private async detectIntegrationsFromCells(notebook: NotebookDocument): Promise<Map<string, IntegrationWithStatus>> {
-        // Collect all cells with SQL integration metadata
-        const blocksWithIntegrations: BlockWithIntegration[] = [];
-
-        for (const cell of notebook.getCells()) {
-            const metadata = cell.metadata;
-            logger.trace(`IntegrationManager: Cell ${cell.index} metadata:`, metadata);
-
-            // Check cell metadata for sql_integration_id
-            if (metadata && typeof metadata === 'object') {
-                const integrationId = (metadata as Record<string, unknown>).sql_integration_id;
-                if (typeof integrationId === 'string') {
-                    logger.debug(`IntegrationManager: Found integration ${integrationId} in cell ${cell.index}`);
-                    blocksWithIntegrations.push({
-                        id: `cell-${cell.index}`,
-                        sql_integration_id: integrationId
-                    });
-                }
-            }
-        }
-
-        logger.debug(`IntegrationManager: Found ${blocksWithIntegrations.length} cells with integrations`);
-
-        // Use the shared utility to scan blocks and build the status map
-        return scanBlocksForIntegrations(blocksWithIntegrations, this.integrationStorage, 'IntegrationManager');
-    }
 }

src/notebooks/deepnote/integrations/integrationUtils.ts

@@ -7,14 +7,8 @@ import { logger } from '../../../platform/logging';
 import { LocalizedMessages, SharedMessages } from '../../../messageTypes';
 import { IDeepnoteNotebookManager, ProjectIntegration } from '../../types';
 import { IIntegrationStorage, IIntegrationWebviewProvider } from './types';
-import {
-    LEGACY_INTEGRATION_TYPE_TO_DEEPNOTE,
-    LegacyIntegrationType,
-    LegacyIntegrationConfig,
-    IntegrationStatus,
-    IntegrationWithStatus,
-    RawLegacyIntegrationType
-} from '../../../platform/notebooks/deepnote/integrationTypes';
+import { IntegrationStatus, IntegrationWithStatus } from '../../../platform/notebooks/deepnote/integrationTypes';
+import { DatabaseIntegrationConfig } from '@deepnote/database-integrations';
 
 /**
  * Manages the webview panel for integration configuration
@@ -222,7 +216,7 @@ export class IntegrationWebviewProvider implements IIntegrationWebviewProvider {
     private async handleMessage(message: {
         type: string;
         integrationId?: string;
-        config?: LegacyIntegrationConfig;
+        config?: DatabaseIntegrationConfig;
     }): Promise<void> {
         switch (message.type) {
             case 'configure':
@@ -264,7 +258,7 @@ export class IntegrationWebviewProvider implements IIntegrationWebviewProvider {
     /**
      * Save the configuration for an integration
      */
-    private async saveConfiguration(integrationId: string, config: LegacyIntegrationConfig): Promise<void> {
+    private async saveConfiguration(integrationId: string, config: DatabaseIntegrationConfig): Promise<void> {
         try {
             await this.integrationStorage.save(config);
 
@@ -351,22 +345,15 @@ export class IntegrationWebviewProvider implements IIntegrationWebviewProvider {
                 }
 
                 // Skip DuckDB integration (internal, not a real Deepnote integration)
-                if (type === LegacyIntegrationType.DuckDB) {
+                if (type === 'pandas-dataframe') {
                     logger.trace(`IntegrationWebviewProvider: Skipping internal DuckDB integration ${id}`);
                     return null;
                 }
 
-                // Map to Deepnote integration type
-                const deepnoteType: RawLegacyIntegrationType | undefined = LEGACY_INTEGRATION_TYPE_TO_DEEPNOTE[type];
-                if (!deepnoteType) {
-                    logger.warn(`IntegrationWebviewProvider: Cannot map type ${type} for integration ${id}, skipping`);
-                    return null;
-                }
-
                 return {
                     id,
                     name: integration.config?.name || integration.integrationName || id,
-                    type: deepnoteType
+                    type
                 };
             })
             .filter((integration): integration is ProjectIntegration => integration !== null);

src/notebooks/deepnote/integrations/integrationWebview.ts

@@ -22,13 +22,9 @@ import { IExtensionSyncActivationService } from '../../platform/activation/types
 import { IDisposableRegistry } from '../../platform/common/types';
 import { IIntegrationStorage } from './integrations/types';
 import { Commands } from '../../platform/common/constants';
-import {
-    DATAFRAME_SQL_INTEGRATION_ID,
-    DEEPNOTE_TO_LEGACY_INTEGRATION_TYPE,
-    LegacyIntegrationType,
-    RawLegacyIntegrationType
-} from '../../platform/notebooks/deepnote/integrationTypes';
+import { DATAFRAME_SQL_INTEGRATION_ID } from '../../platform/notebooks/deepnote/integrationTypes';
 import { IDeepnoteNotebookManager } from '../types';
+import { DatabaseIntegrationType, databaseIntegrationTypes } from '@deepnote/database-integrations';
 
 /**
  * QuickPick item with an integration ID
@@ -347,9 +343,11 @@ export class SqlCellStatusBarProvider implements NotebookCellStatusBarItemProvid
                 continue;
             }
 
-            const integrationType =
-                DEEPNOTE_TO_LEGACY_INTEGRATION_TYPE[projectIntegration.type as RawLegacyIntegrationType];
-            const typeLabel = integrationType ? this.getIntegrationTypeLabel(integrationType) : projectIntegration.type;
+            const integrationType = projectIntegration.type;
+            const typeLabel =
+                integrationType && (databaseIntegrationTypes as readonly string[]).includes(integrationType)
+                    ? this.getIntegrationTypeLabel(integrationType as DatabaseIntegrationType)
+                    : projectIntegration.type;
 
             const item: LocalQuickPickItem = {
                 label: projectIntegration.name || projectIntegration.id,
@@ -432,13 +430,13 @@ export class SqlCellStatusBarProvider implements NotebookCellStatusBarItemProvid
         this._onDidChangeCellStatusBarItems.fire();
     }
 
-    private getIntegrationTypeLabel(type: LegacyIntegrationType): string {
+    private getIntegrationTypeLabel(type: DatabaseIntegrationType): string {
         switch (type) {
-            case LegacyIntegrationType.Postgres:
+            case 'pgsql':
                 return l10n.t('PostgreSQL');
-            case LegacyIntegrationType.BigQuery:
+            case 'big-query':
                 return l10n.t('BigQuery');
-            case LegacyIntegrationType.Snowflake:
+            case 'snowflake':
                 return l10n.t('Snowflake');
             default:
                 return String(type);