/**
* Fabric Tools Extension
* Main entry point for the VS Code extension
*/
import * as vscode from 'vscode';
import { FabricApiService } from './core/api/fabric-api-service';
import { initializeSecurity, AuditLogger, sanitizeErrorForDisplay } from './core/security';
// Import Tree View Providers
import { LakehouseTreeProvider } from './views/lakehouse-tree-provider';
import { PipelineTreeProvider } from './views/pipeline-tree-provider';
import { NotebookTreeProvider } from './views/notebook-tree-provider';
import { MonitoringTreeProvider } from './views/monitoring-tree-provider';
import { DeploymentTreeProvider } from './views/deployment-tree-provider';
import { SchedulingTreeProvider } from './views/scheduling-tree-provider';
import { LineageTreeProvider } from './views/lineage-tree-provider';
import { WarehouseTreeProvider } from './views/warehouse-tree-provider';
import { GitTreeProvider } from './views/git-tree-provider';
import { CapacityTreeProvider } from './views/capacity-tree-provider';
import { EventhouseTreeProvider } from './views/eventhouse-tree-provider';
import { SparkJobTreeProvider } from './views/sparkjob-tree-provider';
import { MirroredDatabaseTreeProvider } from './views/mirrored-database-tree-provider';
import { MLModelTreeProvider } from './views/mlmodel-tree-provider';
import { DataActivatorTreeProvider } from './views/dataactivator-tree-provider';
import { DataflowTreeProvider } from './views/dataflow-tree-provider';
import { DataflowDesignerPanel } from './views/dataflow-designer-panel';
import { DataflowService } from './dataflows/dataflow-service';
import { RealtimeHubTreeProvider, EventstreamDesignerPanel } from './views/realtimehub-tree-provider';
import { DataWranglerTreeProvider, DataWranglerPanel } from './views/datawrangler-tree-provider';
// Extension state
let apiService: FabricApiService;
let currentWorkspaceId: string | undefined;
let outputChannel: vscode.OutputChannel;
// Tree providers
let lakehouseProvider: LakehouseTreeProvider;
let pipelineProvider: PipelineTreeProvider;
let notebookProvider: NotebookTreeProvider;
let monitoringProvider: MonitoringTreeProvider;
let deploymentProvider: DeploymentTreeProvider;
let schedulingProvider: SchedulingTreeProvider;
let lineageProvider: LineageTreeProvider;
let warehouseProvider: WarehouseTreeProvider;
let gitProvider: GitTreeProvider;
let capacityProvider: CapacityTreeProvider;
let eventhouseProvider: EventhouseTreeProvider;
let sparkJobProvider: SparkJobTreeProvider;
let mirroredDatabaseProvider: MirroredDatabaseTreeProvider;
let mlModelProvider: MLModelTreeProvider;
let dataActivatorProvider: DataActivatorTreeProvider;
let dataflowProvider: DataflowTreeProvider;
let realtimeHubProvider: RealtimeHubTreeProvider;
let dataWranglerProvider: DataWranglerTreeProvider;
export function activate(context: vscode.ExtensionContext) {
outputChannel = vscode.window.createOutputChannel('Fabric Tools');
outputChannel.appendLine('Fabric Tools extension activating...');
// Initialize security module first (SECURITY)
initializeSecurity(context);
AuditLogger.log('EXTENSION_ACTIVATING', { version: '2.3.0' });
// Initialize API service with secure storage
apiService = FabricApiService.getInstance();
apiService.initialize(context);
// Initialize tree providers
initializeTreeProviders(context);
// Register commands
registerCommands(context);
// Watch for workspace changes
setupWorkspaceWatcher(context);
AuditLogger.log('EXTENSION_ACTIVATED');
outputChannel.appendLine('Fabric Tools extension activated successfully!');
vscode.window.showInformationMessage('Fabric Tools extension is ready!');
}
function initializeTreeProviders(context: vscode.ExtensionContext): void {
// Lakehouse Explorer
lakehouseProvider = new LakehouseTreeProvider();
const lakehouseTreeView = vscode.window.createTreeView('fabricLakehouse', {
treeDataProvider: lakehouseProvider,
showCollapseAll: true
});
context.subscriptions.push(lakehouseTreeView);
// Pipelines
pipelineProvider = new PipelineTreeProvider();
const pipelineTreeView = vscode.window.createTreeView('fabricPipelines', {
treeDataProvider: pipelineProvider,
showCollapseAll: true
});
context.subscriptions.push(pipelineTreeView);
// Notebooks
notebookProvider = new NotebookTreeProvider();
const notebookTreeView = vscode.window.createTreeView('fabricNotebooks', {
treeDataProvider: notebookProvider,
showCollapseAll: true
});
context.subscriptions.push(notebookTreeView);
// Monitoring Hub
monitoringProvider = new MonitoringTreeProvider();
const monitoringTreeView = vscode.window.createTreeView('fabricMonitoring', {
treeDataProvider: monitoringProvider,
showCollapseAll: true
});
context.subscriptions.push(monitoringTreeView);
// Deployment Pipelines
deploymentProvider = new DeploymentTreeProvider();
const deploymentTreeView = vscode.window.createTreeView('fabricDeployment', {
treeDataProvider: deploymentProvider,
showCollapseAll: true
});
context.subscriptions.push(deploymentTreeView);
// Scheduling
schedulingProvider = new SchedulingTreeProvider();
const schedulingTreeView = vscode.window.createTreeView('fabricScheduling', {
treeDataProvider: schedulingProvider,
showCollapseAll: true
});
context.subscriptions.push(schedulingTreeView);
// Lineage
lineageProvider = new LineageTreeProvider();
const lineageTreeView = vscode.window.createTreeView('fabricLineage', {
treeDataProvider: lineageProvider,
showCollapseAll: true
});
context.subscriptions.push(lineageTreeView);
// SQL Analytics / Warehouse
warehouseProvider = new WarehouseTreeProvider();
const warehouseTreeView = vscode.window.createTreeView('fabricWarehouse', {
treeDataProvider: warehouseProvider,
showCollapseAll: true
});
context.subscriptions.push(warehouseTreeView);
// Git Integration
gitProvider = new GitTreeProvider();
const gitTreeView = vscode.window.createTreeView('fabricGit', {
treeDataProvider: gitProvider,
showCollapseAll: true
});
context.subscriptions.push(gitTreeView);
// Capacity Administration
capacityProvider = new CapacityTreeProvider();
const capacityTreeView = vscode.window.createTreeView('fabricCapacity', {
treeDataProvider: capacityProvider,
showCollapseAll: true
});
context.subscriptions.push(capacityTreeView);
// Eventhouse (KQL Databases)
eventhouseProvider = new EventhouseTreeProvider();
const eventhouseTreeView = vscode.window.createTreeView('fabricEventhouse', {
treeDataProvider: eventhouseProvider,
showCollapseAll: true
});
context.subscriptions.push(eventhouseTreeView);
// Spark Job Definitions
sparkJobProvider = new SparkJobTreeProvider();
const sparkJobTreeView = vscode.window.createTreeView('fabricSparkJobs', {
treeDataProvider: sparkJobProvider,
showCollapseAll: true
});
context.subscriptions.push(sparkJobTreeView);
// Mirrored Databases
mirroredDatabaseProvider = new MirroredDatabaseTreeProvider();
const mirroredDatabaseTreeView = vscode.window.createTreeView('fabricMirroredDb', {
treeDataProvider: mirroredDatabaseProvider,
showCollapseAll: true
});
context.subscriptions.push(mirroredDatabaseTreeView);
// ML Models
mlModelProvider = new MLModelTreeProvider(context);
const mlModelTreeView = vscode.window.createTreeView('fabricMLModels', {
treeDataProvider: mlModelProvider,
showCollapseAll: true
});
context.subscriptions.push(mlModelTreeView);
// Data Activator (Reflex)
dataActivatorProvider = new DataActivatorTreeProvider(context);
const dataActivatorTreeView = vscode.window.createTreeView('fabricDataActivator', {
treeDataProvider: dataActivatorProvider,
showCollapseAll: true
});
context.subscriptions.push(dataActivatorTreeView);
// Dataflows Gen2
dataflowProvider = new DataflowTreeProvider(context);
const dataflowTreeView = vscode.window.createTreeView('fabricDataflows', {
treeDataProvider: dataflowProvider,
showCollapseAll: true
});
context.subscriptions.push(dataflowTreeView);
// Real-Time Hub
realtimeHubProvider = new RealtimeHubTreeProvider(context);
const realtimeHubTreeView = vscode.window.createTreeView('fabricRealtimeHub', {
treeDataProvider: realtimeHubProvider,
showCollapseAll: true
});
context.subscriptions.push(realtimeHubTreeView);
// Data Wrangler
dataWranglerProvider = new DataWranglerTreeProvider(context);
const dataWranglerTreeView = vscode.window.createTreeView('fabricDataWrangler', {
treeDataProvider: dataWranglerProvider,
showCollapseAll: true
});
context.subscriptions.push(dataWranglerTreeView);
}
function registerCommands(context: vscode.ExtensionContext): void {
// Authentication commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.signIn', signIn),
vscode.commands.registerCommand('fabric.signOut', signOut)
);
// Workspace commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.selectWorkspace', selectWorkspace),
vscode.commands.registerCommand('fabric.refreshAll', refreshAllProviders)
);
// Lakehouse commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.lakehouse.refresh', () => lakehouseProvider.refresh()),
vscode.commands.registerCommand('fabric.lakehouse.uploadFile', uploadFile),
vscode.commands.registerCommand('fabric.lakehouse.downloadFile', downloadFile),
vscode.commands.registerCommand('fabric.lakehouse.createFolder', createFolder),
vscode.commands.registerCommand('fabric.lakehouse.deleteFile', deleteFile),
vscode.commands.registerCommand('fabric.lakehouse.createShortcut', createShortcut),
vscode.commands.registerCommand('fabric.lakehouse.optimizeTable', optimizeTable),
vscode.commands.registerCommand('fabric.lakehouse.vacuumTable', vacuumTable),
vscode.commands.registerCommand('fabric.lakehouse.previewTable', previewTable),
vscode.commands.registerCommand('fabric.lakehouse.viewSchema', viewTableSchema)
);
// Pipeline commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.pipeline.refresh', () => pipelineProvider.refresh()),
vscode.commands.registerCommand('fabric.pipeline.run', runPipeline),
vscode.commands.registerCommand('fabric.pipeline.cancel', cancelPipeline),
vscode.commands.registerCommand('fabric.pipeline.viewRuns', viewPipelineRuns),
vscode.commands.registerCommand('fabric.pipeline.create', createPipeline),
vscode.commands.registerCommand('fabric.pipeline.delete', deletePipeline),
vscode.commands.registerCommand('fabric.pipeline.edit', editPipeline),
vscode.commands.registerCommand('fabric.pipeline.openInPortal', openPipelineInPortal)
);
// Notebook commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.notebook.refresh', () => notebookProvider.refresh()),
vscode.commands.registerCommand('fabric.notebook.run', runNotebook),
vscode.commands.registerCommand('fabric.notebook.create', createNotebook),
vscode.commands.registerCommand('fabric.notebook.delete', deleteNotebook),
vscode.commands.registerCommand('fabric.notebook.export', exportNotebook),
vscode.commands.registerCommand('fabric.notebook.setLakehouse', setNotebookLakehouse),
vscode.commands.registerCommand('fabric.notebook.openInPortal', openNotebookInPortal)
);
// Monitoring commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.monitoring.refresh', () => monitoringProvider.refresh()),
vscode.commands.registerCommand('fabric.monitoring.cancelActivity', cancelActivity),
vscode.commands.registerCommand('fabric.monitoring.viewDetails', viewActivityDetails),
vscode.commands.registerCommand('fabric.monitoring.startRealTime', startRealTimeMonitoring),
vscode.commands.registerCommand('fabric.monitoring.stopRealTime', stopRealTimeMonitoring)
);
// Deployment commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.deployment.refresh', () => deploymentProvider.refresh()),
vscode.commands.registerCommand('fabric.deployment.deploy', deployStage),
vscode.commands.registerCommand('fabric.deployment.deploySelected', deploySelectedItems),
vscode.commands.registerCommand('fabric.deployment.create', createDeploymentPipeline),
vscode.commands.registerCommand('fabric.deployment.delete', deleteDeploymentPipeline),
vscode.commands.registerCommand('fabric.deployment.assignWorkspace', assignWorkspaceToStage),
vscode.commands.registerCommand('fabric.deployment.viewHistory', viewDeploymentHistory)
);
// Scheduling commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.scheduling.refresh', () => schedulingProvider.refresh()),
vscode.commands.registerCommand('fabric.scheduling.enable', enableSchedule),
vscode.commands.registerCommand('fabric.scheduling.disable', disableSchedule),
vscode.commands.registerCommand('fabric.scheduling.edit', editSchedule),
vscode.commands.registerCommand('fabric.scheduling.triggerNow', triggerRefreshNow),
vscode.commands.registerCommand('fabric.scheduling.create', createSchedule),
vscode.commands.registerCommand('fabric.scheduling.delete', deleteSchedule)
);
// Lineage commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.lineage.refresh', () => lineageProvider.refresh()),
vscode.commands.registerCommand('fabric.lineage.viewUpstream', viewUpstreamLineage),
vscode.commands.registerCommand('fabric.lineage.viewDownstream', viewDownstreamLineage),
vscode.commands.registerCommand('fabric.lineage.impactAnalysis', runImpactAnalysis),
vscode.commands.registerCommand('fabric.lineage.refreshItem', refreshItemLineage)
);
// Warehouse commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.warehouse.refresh', () => warehouseProvider.refresh()),
vscode.commands.registerCommand('fabric.warehouse.newQuery', newWarehouseQuery),
vscode.commands.registerCommand('fabric.warehouse.previewTable', previewWarehouseTable),
vscode.commands.registerCommand('fabric.warehouse.viewDDL', viewTableDDL),
vscode.commands.registerCommand('fabric.warehouse.pause', pauseWarehouse),
vscode.commands.registerCommand('fabric.warehouse.resume', resumeWarehouse),
vscode.commands.registerCommand('fabric.warehouse.openInPortal', openWarehouseInPortal)
);
// Git commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.git.refresh', () => gitProvider.refresh()),
vscode.commands.registerCommand('fabric.git.commit', commitChanges),
vscode.commands.registerCommand('fabric.git.commitAll', commitAllChanges),
vscode.commands.registerCommand('fabric.git.update', updateFromGit),
vscode.commands.registerCommand('fabric.git.connect', connectToGit),
vscode.commands.registerCommand('fabric.git.disconnect', disconnectFromGit),
vscode.commands.registerCommand('fabric.git.resolveConflict', resolveGitConflict),
vscode.commands.registerCommand('fabric.git.undo', undoChanges),
vscode.commands.registerCommand('fabric.git.switchBranch', switchBranch),
vscode.commands.registerCommand('fabric.git.createBranch', createBranch)
);
// Capacity commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.capacity.refresh', () => capacityProvider.refresh()),
vscode.commands.registerCommand('fabric.capacity.pause', pauseCapacity),
vscode.commands.registerCommand('fabric.capacity.resume', resumeCapacity),
vscode.commands.registerCommand('fabric.capacity.scale', scaleCapacity),
vscode.commands.registerCommand('fabric.capacity.viewUsage', viewCapacityUsage),
vscode.commands.registerCommand('fabric.capacity.viewWorkspaces', viewCapacityWorkspaces),
vscode.commands.registerCommand('fabric.capacity.assignWorkspace', assignWorkspaceToCapacity),
vscode.commands.registerCommand('fabric.capacity.dismissAlert', dismissCapacityAlert)
);
// ML Models commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.mlmodel.refresh', () => mlModelProvider.refresh()),
vscode.commands.registerCommand('fabric.mlmodel.createModel', () => mlModelProvider.createModel()),
vscode.commands.registerCommand('fabric.mlmodel.createExperiment', () => mlModelProvider.createExperiment()),
vscode.commands.registerCommand('fabric.mlmodel.registerVersion', (item) => mlModelProvider.registerModelVersion(item)),
vscode.commands.registerCommand('fabric.mlmodel.transitionStage', (item) => mlModelProvider.transitionModelStage(item)),
vscode.commands.registerCommand('fabric.mlmodel.deleteModel', (item) => mlModelProvider.deleteModel(item)),
vscode.commands.registerCommand('fabric.mlmodel.viewRunInNotebook', (item) => mlModelProvider.viewRunInNotebook(item)),
vscode.commands.registerCommand('fabric.mlmodel.compareRuns', () => mlModelProvider.compareRuns()),
vscode.commands.registerCommand('fabric.mlmodel.downloadArtifact', (item) => mlModelProvider.downloadArtifact(item)),
vscode.commands.registerCommand('fabric.mlmodel.deployModel', (item) => mlModelProvider.deployModel(item))
);
// Data Activator commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.dataactivator.refresh', () => dataActivatorProvider.refresh()),
vscode.commands.registerCommand('fabric.dataactivator.createReflex', () => dataActivatorProvider.createReflex()),
vscode.commands.registerCommand('fabric.dataactivator.addDataSource', (item) => dataActivatorProvider.addDataSource(item)),
vscode.commands.registerCommand('fabric.dataactivator.createObject', (item) => dataActivatorProvider.createObject(item)),
vscode.commands.registerCommand('fabric.dataactivator.createTrigger', (item) => dataActivatorProvider.createTrigger(item)),
vscode.commands.registerCommand('fabric.dataactivator.activateTrigger', (item) => dataActivatorProvider.activateTrigger(item)),
vscode.commands.registerCommand('fabric.dataactivator.pauseTrigger', (item) => dataActivatorProvider.pauseTrigger(item)),
vscode.commands.registerCommand('fabric.dataactivator.testTrigger', (item) => dataActivatorProvider.testTrigger(item)),
vscode.commands.registerCommand('fabric.dataactivator.editCondition', (item) => dataActivatorProvider.editTriggerCondition(item)),
vscode.commands.registerCommand('fabric.dataactivator.editAction', (item) => dataActivatorProvider.editTriggerAction(item)),
vscode.commands.registerCommand('fabric.dataactivator.deleteReflex', (item) => dataActivatorProvider.deleteReflex(item)),
vscode.commands.registerCommand('fabric.dataactivator.deleteTrigger', (item) => dataActivatorProvider.deleteTrigger(item)),
vscode.commands.registerCommand('fabric.dataactivator.viewHistory', (item) => dataActivatorProvider.viewTriggerHistory(item)),
vscode.commands.registerCommand('fabric.dataactivator.openInPortal', (item) => dataActivatorProvider.openInPortal(item))
);
// Dataflows Gen2 commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.dataflow.refresh', () => dataflowProvider.refresh()),
vscode.commands.registerCommand('fabric.dataflow.create', () => dataflowProvider.createDataflow()),
vscode.commands.registerCommand('fabric.dataflow.openDesigner', (item) => {
DataflowDesignerPanel.createOrShow(context.extensionUri, item?.data);
}),
vscode.commands.registerCommand('fabric.dataflow.run', (item) => dataflowProvider.refreshDataflow(item)),
vscode.commands.registerCommand('fabric.dataflow.cancelRefresh', (item) => dataflowProvider.cancelRefresh(item)),
vscode.commands.registerCommand('fabric.dataflow.editSchedule', (item) => dataflowProvider.editSchedule(item)),
vscode.commands.registerCommand('fabric.dataflow.delete', (item) => dataflowProvider.deleteDataflow(item)),
vscode.commands.registerCommand('fabric.dataflow.duplicate', (item) => dataflowProvider.duplicateDataflow(item)),
vscode.commands.registerCommand('fabric.dataflow.viewRefreshDetails', (item) => dataflowProvider.viewRefreshDetails(item)),
vscode.commands.registerCommand('fabric.dataflow.exportJson', (item) => dataflowProvider.exportToJson(item)),
vscode.commands.registerCommand('fabric.dataflow.importJson', () => dataflowProvider.importFromJson())
);
// Real-Time Hub commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.realtimehub.refresh', () => realtimeHubProvider.refresh()),
vscode.commands.registerCommand('fabric.realtimehub.createEventstream', () => realtimeHubProvider.createEventstream()),
vscode.commands.registerCommand('fabric.realtimehub.openDesigner', (item) => realtimeHubProvider.openDesigner(item)),
vscode.commands.registerCommand('fabric.realtimehub.startEventstream', (item) => realtimeHubProvider.startEventstream(item)),
vscode.commands.registerCommand('fabric.realtimehub.stopEventstream', (item) => realtimeHubProvider.stopEventstream(item)),
vscode.commands.registerCommand('fabric.realtimehub.deleteEventstream', (item) => realtimeHubProvider.deleteEventstream(item)),
vscode.commands.registerCommand('fabric.realtimehub.addSource', (item) => realtimeHubProvider.addSource(item)),
vscode.commands.registerCommand('fabric.realtimehub.addDestination', (item) => realtimeHubProvider.addDestination(item)),
vscode.commands.registerCommand('fabric.realtimehub.addTransform', (item) => realtimeHubProvider.addTransformation(item)),
vscode.commands.registerCommand('fabric.realtimehub.viewMetrics', (item) => realtimeHubProvider.viewMetrics(item)),
vscode.commands.registerCommand('fabric.realtimehub.viewStreamData', (item) => realtimeHubProvider.viewStreamData(item))
);
// Data Wrangler commands
context.subscriptions.push(
vscode.commands.registerCommand('fabric.datawrangler.refresh', () => dataWranglerProvider.refresh()),
vscode.commands.registerCommand('fabric.datawrangler.newSession', () => dataWranglerProvider.newSession()),
vscode.commands.registerCommand('fabric.datawrangler.openWrangler', (item) => dataWranglerProvider.openWrangler(item)),
vscode.commands.registerCommand('fabric.datawrangler.transform', (item) => dataWranglerProvider.applyTransform(item)),
vscode.commands.registerCommand('fabric.datawrangler.undoStep', (item) => dataWranglerProvider.undoStep(item)),
vscode.commands.registerCommand('fabric.datawrangler.exportCode', () => dataWranglerProvider.exportCode()),
vscode.commands.registerCommand('fabric.datawrangler.viewProfile', (item) => dataWranglerProvider.viewColumnProfile(item)),
vscode.commands.registerCommand('fabric.datawrangler.fixIssue', (item) => dataWranglerProvider.fixIssue(item)),
vscode.commands.registerCommand('fabric.datawrangler.saveSession', (item) => dataWranglerProvider.saveSession(item)),
vscode.commands.registerCommand('fabric.datawrangler.deleteSession', (item) => dataWranglerProvider.deleteSession(item))
);
}
function setupWorkspaceWatcher(context: vscode.ExtensionContext): void {
// Watch for configuration changes
context.subscriptions.push(
vscode.workspace.onDidChangeConfiguration(e => {
if (e.affectsConfiguration('fabricTools')) {
outputChannel.appendLine('Configuration changed, refreshing...');
refreshAllProviders();
}
})
);
}
// Refresh all tree providers
function refreshAllProviders(): void {
lakehouseProvider.refresh();
pipelineProvider.refresh();
notebookProvider.refresh();
monitoringProvider.refresh();
deploymentProvider.refresh();
schedulingProvider.refresh();
lineageProvider.refresh();
warehouseProvider.refresh();
gitProvider.refresh();
capacityProvider.refresh();
eventhouseProvider.refresh();
sparkJobProvider.refresh();
mirroredDatabaseProvider.refresh();
mlModelProvider.refresh();
dataActivatorProvider.refresh();
dataflowProvider.refresh();
realtimeHubProvider.refresh();
dataWranglerProvider.refresh();
}
// Set workspace for all providers
function setWorkspaceForAllProviders(workspaceId: string): void {
currentWorkspaceId = workspaceId;
lakehouseProvider.setWorkspace(workspaceId);
pipelineProvider.setWorkspace(workspaceId);
notebookProvider.setWorkspace(workspaceId);
monitoringProvider.setWorkspace(workspaceId);
schedulingProvider.setWorkspace(workspaceId);
warehouseProvider.setWorkspace(workspaceId);
eventhouseProvider.setWorkspace(workspaceId);
sparkJobProvider.setWorkspace(workspaceId);
mirroredDatabaseProvider.setWorkspace(workspaceId);
mlModelProvider.setWorkspace(workspaceId);
dataActivatorProvider.setWorkspace(workspaceId);
dataflowProvider.setWorkspace(workspaceId);
realtimeHubProvider.setWorkspace(workspaceId);
dataWranglerProvider.setWorkspace(workspaceId);
// Note: lineageProvider uses setCurrentItem instead of setWorkspace
// Note: gitProvider uses setWorkspace if available
if ('setWorkspace' in gitProvider) {
(gitProvider as any).setWorkspace(workspaceId);
}
// Note: Deployment and Capacity providers are workspace-independent
}
// ============ Command Implementations ============
async function signIn(): Promise<void> {
try {
// In a real implementation, use Azure AD authentication
vscode.window.showInformationMessage('Signing in to Microsoft Fabric...');
// This would typically use vscode.authentication.getSession
AuditLogger.log('SIGN_IN_ATTEMPT');
} catch (error) {
// HIGH-002: Sanitize error message before display
AuditLogger.log('SIGN_IN_FAILED', { error: error instanceof Error ? error.message : 'Unknown' });
vscode.window.showErrorMessage(`Sign in failed: ${sanitizeErrorForDisplay(error)}`);
}
}
async function signOut(): Promise<void> {
await apiService.clearToken();
AuditLogger.log('SIGN_OUT');
vscode.window.showInformationMessage('Signed out of Microsoft Fabric');
}
async function selectWorkspace(): Promise<void> {
const workspaceId = await vscode.window.showInputBox({
prompt: 'Enter Workspace ID',
placeHolder: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
// HIGH-003: Add input validation
validateInput: (value) => {
if (!value || value.trim().length === 0) {
return 'Workspace ID is required';
}
// Validate UUID format
const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
if (!uuidRegex.test(value.trim())) {
return 'Invalid Workspace ID format. Expected UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx';
}
return null;
}
});
if (workspaceId) {
AuditLogger.log('WORKSPACE_SELECTED', { workspaceId: workspaceId.substring(0, 8) + '...' });
setWorkspaceForAllProviders(workspaceId);
refreshAllProviders();
vscode.window.showInformationMessage(`Workspace selected: ${workspaceId}`);
}
}
// Lakehouse commands
async function uploadFile(item?: any): Promise<void> {
vscode.window.showInformationMessage('Upload file to OneLake');
}
async function downloadFile(item?: any): Promise<void> {
vscode.window.showInformationMessage('Download file from OneLake');
}
async function createFolder(item?: any): Promise<void> {
vscode.window.showInformationMessage('Create folder in OneLake');
}
async function deleteFile(item?: any): Promise<void> {
vscode.window.showInformationMessage('Delete file from OneLake');
}
async function createShortcut(item?: any): Promise<void> {
vscode.window.showInformationMessage('Create shortcut');
}
async function optimizeTable(item?: any): Promise<void> {
vscode.window.showInformationMessage('Optimize Delta table');
}
async function vacuumTable(item?: any): Promise<void> {
vscode.window.showInformationMessage('Vacuum Delta table');
}
async function previewTable(item?: any): Promise<void> {
vscode.window.showInformationMessage('Preview Delta table');
}
async function viewTableSchema(item?: any): Promise<void> {
vscode.window.showInformationMessage('View table schema');
}
// Pipeline commands
async function runPipeline(item?: any): Promise<void> {
vscode.window.showInformationMessage('Running pipeline...');
}
async function cancelPipeline(item?: any): Promise<void> {
vscode.window.showInformationMessage('Cancelling pipeline...');
}
async function viewPipelineRuns(item?: any): Promise<void> {
vscode.window.showInformationMessage('View pipeline runs');
}
async function createPipeline(): Promise<void> {
vscode.window.showInformationMessage('Create pipeline');
}
async function deletePipeline(item?: any): Promise<void> {
vscode.window.showInformationMessage('Delete pipeline');
}
async function editPipeline(item?: any): Promise<void> {
vscode.window.showInformationMessage('Edit pipeline');
}
async function openPipelineInPortal(item?: any): Promise<void> {
vscode.window.showInformationMessage('Open in Fabric Portal');
}
// Notebook commands
async function runNotebook(item?: any): Promise<void> {
vscode.window.showInformationMessage('Running notebook...');
}
async function createNotebook(): Promise<void> {
vscode.window.showInformationMessage('Create notebook');
}
async function deleteNotebook(item?: any): Promise<void> {
vscode.window.showInformationMessage('Delete notebook');
}
async function exportNotebook(item?: any): Promise<void> {
vscode.window.showInformationMessage('Export notebook to .ipynb');
}
async function setNotebookLakehouse(item?: any): Promise<void> {
vscode.window.showInformationMessage('Set default lakehouse');
}
async function openNotebookInPortal(item?: any): Promise<void> {
vscode.window.showInformationMessage('Open in Fabric Portal');
}
// Monitoring commands
async function cancelActivity(item?: any): Promise<void> {
vscode.window.showInformationMessage('Cancel activity');
}
async function viewActivityDetails(item?: any): Promise<void> {
vscode.window.showInformationMessage('View activity details');
}
async function startRealTimeMonitoring(): Promise<void> {
vscode.window.showInformationMessage('Starting real-time monitoring...');
}
async function stopRealTimeMonitoring(): Promise<void> {
vscode.window.showInformationMessage('Stopping real-time monitoring');
}
// Deployment commands
async function deployStage(item?: any): Promise<void> {
vscode.window.showInformationMessage('Deploy to next stage');
}
async function deploySelectedItems(item?: any): Promise<void> {
vscode.window.showInformationMessage('Deploy selected items');
}
async function createDeploymentPipeline(): Promise<void> {
vscode.window.showInformationMessage('Create deployment pipeline');
}
async function deleteDeploymentPipeline(item?: any): Promise<void> {
vscode.window.showInformationMessage('Delete deployment pipeline');
}
async function assignWorkspaceToStage(item?: any): Promise<void> {
vscode.window.showInformationMessage('Assign workspace to stage');
}
async function viewDeploymentHistory(item?: any): Promise<void> {
vscode.window.showInformationMessage('View deployment history');
}
// Scheduling commands
async function enableSchedule(item?: any): Promise<void> {
vscode.window.showInformationMessage('Enable schedule');
}
async function disableSchedule(item?: any): Promise<void> {
vscode.window.showInformationMessage('Disable schedule');
}
async function editSchedule(item?: any): Promise<void> {
vscode.window.showInformationMessage('Edit schedule');
}
async function triggerRefreshNow(item?: any): Promise<void> {
vscode.window.showInformationMessage('Triggering refresh...');
}
async function createSchedule(item?: any): Promise<void> {
vscode.window.showInformationMessage('Create schedule');
}
async function deleteSchedule(item?: any): Promise<void> {
vscode.window.showInformationMessage('Delete schedule');
}
// Lineage commands
async function viewUpstreamLineage(item?: any): Promise<void> {
vscode.window.showInformationMessage('View upstream lineage');
}
async function viewDownstreamLineage(item?: any): Promise<void> {
vscode.window.showInformationMessage('View downstream lineage');
}
async function runImpactAnalysis(item?: any): Promise<void> {
vscode.window.showInformationMessage('Running impact analysis...');
}
async function refreshItemLineage(item?: any): Promise<void> {
vscode.window.showInformationMessage('Refresh lineage');
}
// Warehouse commands
async function newWarehouseQuery(): Promise<void> {
vscode.window.showInformationMessage('New SQL query');
}
async function previewWarehouseTable(item?: any): Promise<void> {
vscode.window.showInformationMessage('Preview table data');
}
async function viewTableDDL(item?: any): Promise<void> {
vscode.window.showInformationMessage('View table DDL');
}
async function pauseWarehouse(item?: any): Promise<void> {
vscode.window.showInformationMessage('Pause warehouse');
}
async function resumeWarehouse(item?: any): Promise<void> {
vscode.window.showInformationMessage('Resume warehouse');
}
async function openWarehouseInPortal(item?: any): Promise<void> {
vscode.window.showInformationMessage('Open in Fabric Portal');
}
// Git commands
async function commitChanges(item?: any): Promise<void> {
vscode.window.showInformationMessage('Commit changes');
}
async function commitAllChanges(): Promise<void> {
vscode.window.showInformationMessage('Commit all changes');
}
async function updateFromGit(): Promise<void> {
vscode.window.showInformationMessage('Update from Git');
}
async function connectToGit(): Promise<void> {
vscode.window.showInformationMessage('Connect to Git repository');
}
async function disconnectFromGit(): Promise<void> {
vscode.window.showInformationMessage('Disconnect from Git');
}
async function resolveGitConflict(item?: any): Promise<void> {
vscode.window.showInformationMessage('Resolve conflict');
}
async function undoChanges(item?: any): Promise<void> {
vscode.window.showInformationMessage('Undo changes');
}
async function switchBranch(): Promise<void> {
vscode.window.showInformationMessage('Switch branch');
}
async function createBranch(): Promise<void> {
vscode.window.showInformationMessage('Create branch');
}
// Capacity commands
async function pauseCapacity(item?: any): Promise<void> {
vscode.window.showInformationMessage('Pause capacity');
}
async function resumeCapacity(item?: any): Promise<void> {
vscode.window.showInformationMessage('Resume capacity');
}
async function scaleCapacity(item?: any): Promise<void> {
vscode.window.showInformationMessage('Scale capacity');
}
async function viewCapacityUsage(item?: any): Promise<void> {
vscode.window.showInformationMessage('View capacity usage');
}
async function viewCapacityWorkspaces(item?: any): Promise<void> {
vscode.window.showInformationMessage('View assigned workspaces');
}
async function assignWorkspaceToCapacity(item?: any): Promise<void> {
vscode.window.showInformationMessage('Assign workspace to capacity');
}
async function dismissCapacityAlert(item?: any): Promise<void> {
vscode.window.showInformationMessage('Dismiss alert');
}
export function deactivate() {
outputChannel.appendLine('Fabric Tools extension deactivating...');
outputChannel.dispose();
}
