/**
* Feature Commands Registration
* Registers all commands for the 10 Fabric Portal features
*/
import * as vscode from 'vscode';
import { LakehouseTreeProvider, LakehouseTreeItem } from '../views/lakehouse-tree-provider';
import { PipelineTreeProvider, PipelineTreeItem } from '../views/pipeline-tree-provider';
import { NotebookTreeProvider, NotebookTreeItem } from '../views/notebook-tree-provider';
import { MonitoringTreeProvider, MonitoringTreeItem } from '../views/monitoring-tree-provider';
import { DeploymentTreeProvider, DeploymentTreeItem } from '../views/deployment-tree-provider';
import { SchedulingTreeProvider, SchedulingTreeItem } from '../views/scheduling-tree-provider';
import { LineageTreeProvider, LineageTreeItem } from '../views/lineage-tree-provider';
import { WarehouseTreeProvider, WarehouseTreeItem } from '../views/warehouse-tree-provider';
import { GitTreeProvider, GitTreeItem } from '../views/git-tree-provider';
import { CapacityTreeProvider, CapacityTreeItem } from '../views/capacity-tree-provider';
export interface FeatureProviders {
lakehouse: LakehouseTreeProvider;
pipeline: PipelineTreeProvider;
notebook: NotebookTreeProvider;
monitoring: MonitoringTreeProvider;
deployment: DeploymentTreeProvider;
scheduling: SchedulingTreeProvider;
lineage: LineageTreeProvider;
warehouse: WarehouseTreeProvider;
git: GitTreeProvider;
capacity: CapacityTreeProvider;
}
export function registerFeatureCommands(
context: vscode.ExtensionContext,
providers: FeatureProviders
): void {
const { lakehouse, pipeline, notebook, monitoring, deployment, scheduling, lineage, warehouse, git, capacity } = providers;
// ===== LAKEHOUSE COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.lakehouse.refresh', () => lakehouse.refresh()),
vscode.commands.registerCommand('fabric.lakehouse.browse', async (item: LakehouseTreeItem) => {
if (item?.lakehouseId && item?.workspaceId) {
vscode.window.showInformationMessage(`Browsing lakehouse: ${item.label}`);
}
}),
vscode.commands.registerCommand('fabric.lakehouse.upload', async () => {
const fileUri = await vscode.window.showOpenDialog({
canSelectMany: false,
title: 'Select file to upload'
});
if (fileUri && fileUri[0]) {
vscode.window.showInformationMessage(`Uploading: ${fileUri[0].fsPath}`);
}
}),
vscode.commands.registerCommand('fabric.lakehouse.download', async (item: LakehouseTreeItem) => {
if (item?.path) {
const saveUri = await vscode.window.showSaveDialog({
defaultUri: vscode.Uri.file(item.label),
title: 'Save file as'
});
if (saveUri) {
vscode.window.showInformationMessage(`Downloading to: ${saveUri.fsPath}`);
}
}
}),
vscode.commands.registerCommand('fabric.lakehouse.createFolder', async (item: LakehouseTreeItem) => {
const name = await vscode.window.showInputBox({ prompt: 'Enter folder name' });
if (name) {
vscode.window.showInformationMessage(`Creating folder: ${name}`);
}
}),
vscode.commands.registerCommand('fabric.lakehouse.delete', async (item: LakehouseTreeItem) => {
const confirmed = await vscode.window.showWarningMessage(
`Delete "${item?.label}"?`, { modal: true }, 'Delete'
);
if (confirmed === 'Delete') {
vscode.window.showInformationMessage(`Deleted: ${item?.label}`);
lakehouse.refresh();
}
}),
vscode.commands.registerCommand('fabric.lakehouse.previewTable', async (item: LakehouseTreeItem) => {
vscode.window.showInformationMessage(`Previewing table: ${item?.label}`);
}),
vscode.commands.registerCommand('fabric.lakehouse.createShortcut', async () => {
vscode.window.showInformationMessage('Creating shortcut...');
}),
vscode.commands.registerCommand('fabric.lakehouse.loadTable', async (item: LakehouseTreeItem) => {
vscode.window.showInformationMessage(`Loading table from: ${item?.label}`);
}),
vscode.commands.registerCommand('fabric.lakehouse.optimizeTable', async (item: LakehouseTreeItem) => {
vscode.window.showInformationMessage(`Optimizing table: ${item?.label}`);
})
);
// ===== PIPELINE COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.pipeline.refresh', () => pipeline.refresh()),
vscode.commands.registerCommand('fabric.pipeline.run', (item: PipelineTreeItem) => pipeline.runPipeline(item)),
vscode.commands.registerCommand('fabric.pipeline.cancel', (item: PipelineTreeItem) => pipeline.cancelRun(item)),
vscode.commands.registerCommand('fabric.pipeline.viewHistory', (item: PipelineTreeItem) => {
vscode.window.showInformationMessage(`Viewing history for: ${item?.label}`);
}),
vscode.commands.registerCommand('fabric.pipeline.viewLogs', (item: PipelineTreeItem) => pipeline.viewRunLogs(item))
);
// ===== NOTEBOOK COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.notebook.refresh', () => notebook.refresh()),
vscode.commands.registerCommand('fabric.notebook.create', () => notebook.createNotebook()),
vscode.commands.registerCommand('fabric.notebook.open', (item: NotebookTreeItem) => notebook.openNotebook(item)),
vscode.commands.registerCommand('fabric.notebook.run', (item: NotebookTreeItem) => notebook.runNotebook(item)),
vscode.commands.registerCommand('fabric.notebook.delete', (item: NotebookTreeItem) => notebook.deleteNotebook(item)),
vscode.commands.registerCommand('fabric.notebook.manageSession', (item: NotebookTreeItem) => notebook.manageSession(item))
);
// ===== WAREHOUSE COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.warehouse.refresh', () => warehouse.refresh()),
vscode.commands.registerCommand('fabric.warehouse.newQuery', (item?: WarehouseTreeItem) => warehouse.newQuery(item)),
vscode.commands.registerCommand('fabric.warehouse.previewTable', (item: WarehouseTreeItem) => warehouse.previewTable(item)),
vscode.commands.registerCommand('fabric.warehouse.generateSelect', (item: WarehouseTreeItem) => warehouse.generateSelect(item)),
vscode.commands.registerCommand('fabric.warehouse.viewDefinition', (item: WarehouseTreeItem) => warehouse.viewDefinition(item)),
vscode.commands.registerCommand('fabric.warehouse.copyConnectionString', (item: WarehouseTreeItem) => warehouse.copyConnectionString(item)),
vscode.commands.registerCommand('fabric.warehouse.pause', (item: WarehouseTreeItem) => warehouse.pauseWarehouse(item)),
vscode.commands.registerCommand('fabric.warehouse.resume', (item: WarehouseTreeItem) => warehouse.resumeWarehouse(item))
);
// ===== MONITORING COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.monitoring.refresh', () => monitoring.refresh()),
vscode.commands.registerCommand('fabric.monitoring.cancelRefresh', (item: MonitoringTreeItem) => monitoring.cancelRefresh(item)),
vscode.commands.registerCommand('fabric.monitoring.viewDetails', (item: MonitoringTreeItem) => monitoring.viewRefreshDetails(item)),
vscode.commands.registerCommand('fabric.monitoring.cancelQuery', (item: MonitoringTreeItem) => monitoring.cancelQuery(item))
);
// ===== DEPLOYMENT COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.deployment.refresh', () => deployment.refresh()),
vscode.commands.registerCommand('fabric.deployment.create', () => deployment.createPipeline()),
vscode.commands.registerCommand('fabric.deployment.deploy', (item: DeploymentTreeItem) => deployment.deploy(item)),
vscode.commands.registerCommand('fabric.deployment.compare', (item: DeploymentTreeItem) => deployment.compareStages(item)),
vscode.commands.registerCommand('fabric.deployment.assignWorkspace', (item: DeploymentTreeItem) => deployment.assignWorkspace(item)),
vscode.commands.registerCommand('fabric.deployment.viewHistory', (item: DeploymentTreeItem) => deployment.viewOperationDetails(item))
);
// ===== SCHEDULING COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.scheduling.refresh', () => scheduling.refresh()),
vscode.commands.registerCommand('fabric.scheduling.create', () => scheduling.createSchedule()),
vscode.commands.registerCommand('fabric.scheduling.edit', (item: SchedulingTreeItem) => scheduling.editSchedule(item)),
vscode.commands.registerCommand('fabric.scheduling.toggle', (item: SchedulingTreeItem) => scheduling.toggleSchedule(item)),
vscode.commands.registerCommand('fabric.scheduling.delete', (item: SchedulingTreeItem) => scheduling.deleteSchedule(item)),
vscode.commands.registerCommand('fabric.scheduling.runNow', (item: SchedulingTreeItem) => scheduling.triggerRefreshNow(item)),
vscode.commands.registerCommand('fabric.scheduling.viewHistory', (item: SchedulingTreeItem) => scheduling.viewHistoryDetails(item))
);
// ===== LINEAGE COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.lineage.refresh', () => lineage.refresh()),
vscode.commands.registerCommand('fabric.lineage.showGraph', () => lineage.showFullLineageGraph()),
vscode.commands.registerCommand('fabric.lineage.impactAnalysis', (item: LineageTreeItem) => lineage.runImpactAnalysis(item)),
vscode.commands.registerCommand('fabric.lineage.navigate', (item: LineageTreeItem) => lineage.navigateToItem(item))
);
// ===== GIT COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.git.refresh', () => git.refresh()),
vscode.commands.registerCommand('fabric.git.connect', (item: GitTreeItem) => git.connectToGit(item)),
vscode.commands.registerCommand('fabric.git.disconnect', (item: GitTreeItem) => git.disconnectFromGit(item)),
vscode.commands.registerCommand('fabric.git.commit', (item: GitTreeItem) => git.commitChanges(item)),
vscode.commands.registerCommand('fabric.git.sync', (item: GitTreeItem) => git.syncChanges(item)),
vscode.commands.registerCommand('fabric.git.pull', (item: GitTreeItem) => git.pullChanges(item)),
vscode.commands.registerCommand('fabric.git.push', (item: GitTreeItem) => git.pushChanges(item)),
vscode.commands.registerCommand('fabric.git.switchBranch', (item: GitTreeItem) => git.switchBranch(item)),
vscode.commands.registerCommand('fabric.git.createBranch', (item: GitTreeItem) => git.createBranch(item)),
vscode.commands.registerCommand('fabric.git.resolveConflict', (item: GitTreeItem) => git.resolveConflict(item)),
vscode.commands.registerCommand('fabric.git.undoChange', (item: GitTreeItem) => git.undoChange(item))
);
// ===== CAPACITY COMMANDS =====
context.subscriptions.push(
vscode.commands.registerCommand('fabric.capacity.refresh', () => capacity.refresh()),
vscode.commands.registerCommand('fabric.capacity.pause', (item: CapacityTreeItem) => capacity.pauseCapacity(item)),
vscode.commands.registerCommand('fabric.capacity.resume', (item: CapacityTreeItem) => capacity.resumeCapacity(item)),
vscode.commands.registerCommand('fabric.capacity.scale', (item: CapacityTreeItem) => capacity.scaleCapacity(item)),
vscode.commands.registerCommand('fabric.capacity.toggleWorkload', (item: CapacityTreeItem) => capacity.toggleWorkload(item)),
vscode.commands.registerCommand('fabric.capacity.acknowledgeAlert', (item: CapacityTreeItem) => capacity.acknowledgeAlert(item)),
vscode.commands.registerCommand('fabric.capacity.openDashboard', (item: CapacityTreeItem) => capacity.openMetricsDashboard(item)),
vscode.commands.registerCommand('fabric.capacity.settings', (item: CapacityTreeItem) => capacity.viewCapacitySettings(item))
);
}
/**
* Register all feature tree views
*/
export function registerFeatureViews(context: vscode.ExtensionContext): FeatureProviders {
const lakehouse = new LakehouseTreeProvider();
const pipeline = new PipelineTreeProvider();
const notebook = new NotebookTreeProvider();
const monitoring = new MonitoringTreeProvider();
const deployment = new DeploymentTreeProvider();
const scheduling = new SchedulingTreeProvider();
const lineage = new LineageTreeProvider();
const warehouse = new WarehouseTreeProvider();
const git = new GitTreeProvider();
const capacity = new CapacityTreeProvider();
// Register tree data providers
context.subscriptions.push(
vscode.window.registerTreeDataProvider('fabricLakehouse', lakehouse),
vscode.window.registerTreeDataProvider('fabricPipelines', pipeline),
vscode.window.registerTreeDataProvider('fabricNotebooks', notebook),
vscode.window.registerTreeDataProvider('fabricMonitoring', monitoring),
vscode.window.registerTreeDataProvider('fabricDeployment', deployment),
vscode.window.registerTreeDataProvider('fabricScheduling', scheduling),
vscode.window.registerTreeDataProvider('fabricLineage', lineage),
vscode.window.registerTreeDataProvider('fabricWarehouse', warehouse),
vscode.window.registerTreeDataProvider('fabricGit', git),
vscode.window.registerTreeDataProvider('fabricCapacity', capacity)
);
// Dispose monitoring and capacity timers on deactivation
context.subscriptions.push({
dispose: () => {
monitoring.dispose();
capacity.dispose();
}
});
return { lakehouse, pipeline, notebook, monitoring, deployment, scheduling, lineage, warehouse, git, capacity };
}
/**
* Update all feature providers when workspace changes
*/
export function setFeatureWorkspace(providers: FeatureProviders, workspaceId: string): void {
providers.lakehouse.setWorkspace(workspaceId);
providers.pipeline.setWorkspace(workspaceId);
providers.notebook.setWorkspace(workspaceId);
providers.monitoring.setWorkspace(workspaceId);
providers.scheduling.setWorkspace(workspaceId);
providers.warehouse.setWorkspace(workspaceId);
}
