Merge branch 'main' into bi-dm-undo-fix

Author: KCSAbeywickrama

.trivyignore

@@ -1,13 +1,6 @@
 # Trivy ignore file for known low-risk vulnerabilities
 # Format: CVE-ID or vulnerability ID
 
-# Low severity vulnerability in jsondiffpatch package
-# Used as transitive dependency via 'ai' package
-# Risk Assessment: LOW severity, limited impact on diff operations
-# Decision: Acceptable risk - waiting for ai package to update jsondiffpatch dependency
-# Related Issue: https://github.com/wso2/product-ballerina-integrator/issues/1274
-CVE-2025-9910
-
 # No fix released by the author
 # https://github.com/wso2/vscode-extensions/issues/550
 CVE-2020-36851

common/config/rush/pnpm-lock.yaml

@@ -57,9 +57,10 @@ export enum IntermediateClauseType {
     LET = "let",
     WHERE = "where",
     FROM = "from",
-    ORDER_BY = "order by",
+    ORDER_BY = "order-by",
     LIMIT = "limit",
     JOIN = "join",
+    GROUP_BY = "group-by"
 }
 
 export enum ResultClauseType {
@@ -95,6 +96,7 @@ export interface IOType {
     defaultValue?: unknown;
     optional?: boolean;
     isFocused?: boolean;
+    isSeq?: boolean;
     isRecursive?: boolean;
     isDeepNested?: boolean;
     ref?: string;
@@ -141,6 +143,7 @@ export interface DMModel {
     triggerRefresh?: boolean;
     traversingRoot?: string;
     focusInputRootMap?: Record<string, string>;
+    groupById?: string;
 }
 
 export interface ModelState {
@@ -175,6 +178,7 @@ export interface IOTypeField {
     optional?: boolean;
     ref?: string;
     focusExpression?: string;
+    isSeq?: boolean;
     typeInfo?: TypeInfo;
 }
 
@@ -192,7 +196,7 @@ export interface Query {
     output: string,
     inputs: string[];
     diagnostics?: DMDiagnostic[];
-    fromClause: FromClause;
+    fromClause: IntermediateClause;
     intermediateClauses?: IntermediateClause[];
     resultClause: ResultClause;
 }

workspaces/ballerina/ballerina-core/src/interfaces/data-mapper.ts

@@ -32,7 +32,8 @@ import {
     FileOrDirRequest,
     WorkspaceRootResponse,
     ShowErrorMessageRequest,
-    WorkspaceTypeResponse
+    WorkspaceTypeResponse,
+    SampleDownloadRequest
 } from "./interfaces";
 
 export interface CommonRPCAPI {
@@ -51,4 +52,5 @@ export interface CommonRPCAPI {
     showErrorMessage: (params: ShowErrorMessageRequest) => void;
     getCurrentProjectTomlValues: () => Promise<Record<string, any>>;
     getWorkspaceType: () => Promise<WorkspaceTypeResponse>;
+    downloadSelectedSampleFromGithub: (params: SampleDownloadRequest) => Promise<boolean>;
 }

workspaces/ballerina/ballerina-core/src/rpc-types/common/index.ts

@@ -113,3 +113,7 @@ export interface PackageTomlValues {
 export interface WorkspaceTypeResponse {
     type: "SINGLE_PROJECT" | "MULTIPLE_PROJECTS" | "BALLERINA_WORKSPACE" | "VSCODE_WORKSPACE" | "UNKNOWN"
 }
+
+export interface SampleDownloadRequest {
+    zipFileName: string;
+}

workspaces/ballerina/ballerina-core/src/rpc-types/common/interfaces.ts

@@ -33,7 +33,8 @@ import {
     FileOrDirRequest,
     WorkspaceRootResponse,
     ShowErrorMessageRequest,
-    WorkspaceTypeResponse
+    WorkspaceTypeResponse,
+    SampleDownloadRequest
 } from "./interfaces";
 import { RequestType, NotificationType } from "vscode-messenger-common";
 
@@ -53,3 +54,4 @@ export const getWorkspaceRoot: RequestType<void, WorkspaceRootResponse> = { meth
 export const showErrorMessage: NotificationType<ShowErrorMessageRequest> = { method: `${_preFix}/showErrorMessage` };
 export const getCurrentProjectTomlValues: RequestType<void, void> = { method: `${_preFix}/getCurrentProjectTomlValues` };
 export const getWorkspaceType: RequestType<void, WorkspaceTypeResponse> = { method: `${_preFix}/getWorkspaceType` };
+export const downloadSelectedSampleFromGithub: RequestType<SampleDownloadRequest, boolean> = { method: `${_preFix}/downloadSelectedSampleFromGithub` };

workspaces/ballerina/ballerina-core/src/rpc-types/common/rpc-type.ts

@@ -99,7 +99,8 @@ export enum MACHINE_VIEW {
     AIAgentDesigner = "AI Agent Designer",
     AIChatAgentWizard = "AI Chat Agent Wizard",
     ResolveMissingDependencies = "Resolve Missing Dependencies",
-    ServiceFunctionForm = "Service Function Form"
+    ServiceFunctionForm = "Service Function Form",
+    BISamplesView = "BI Samples View"
 }
 
 export interface MachineEvent {

workspaces/ballerina/ballerina-core/src/state-machine-types.ts

@@ -1214,6 +1214,7 @@
         "portfinder": "^1.0.32",
         "source-map-support": "^0.5.21",
         "toml": "^3.0.0",
+        "unzipper": "~0.12.3",
         "uuid": "^11.1.0",
         "vscode-debugadapter": "^1.51.0",
         "vscode-debugprotocol": "^1.51.0",

workspaces/ballerina/ballerina-extension/package.json

@@ -20,27 +20,29 @@
 import {
     BallerinaDiagnosticsRequest,
     CommandsRequest,
-    FileOrDirRequest,
-    GoToSourceRequest,
-    OpenExternalUrlRequest,
-    RunExternalCommandRequest,
-    ShowErrorMessageRequest,
-    WorkspaceFileRequest,
+    downloadSelectedSampleFromGithub,
     executeCommand,
     experimentalEnabled,
+    FileOrDirRequest,
     getBallerinaDiagnostics,
     getCurrentProjectTomlValues,
     getTypeCompletions,
     getWorkspaceFiles,
     getWorkspaceRoot,
     getWorkspaceType,
     goToSource,
+    GoToSourceRequest,
     isNPSupported,
     openExternalUrl,
+    OpenExternalUrlRequest,
     runBackgroundTerminalCommand,
+    RunExternalCommandRequest,
+    SampleDownloadRequest,
     selectFileOrDirPath,
     selectFileOrFolderPath,
-    showErrorMessage
+    showErrorMessage,
+    ShowErrorMessageRequest,
+    WorkspaceFileRequest
 } from "@wso2/ballerina-core";
 import { Messenger } from "vscode-messenger";
 import { CommonRpcManager } from "./rpc-manager";
@@ -62,4 +64,5 @@ export function registerCommonRpcHandlers(messenger: Messenger) {
     messenger.onNotification(showErrorMessage, (args: ShowErrorMessageRequest) => rpcManger.showErrorMessage(args));
     messenger.onRequest(getCurrentProjectTomlValues, () => rpcManger.getCurrentProjectTomlValues());
     messenger.onRequest(getWorkspaceType, () => rpcManger.getWorkspaceType());
+    messenger.onRequest(downloadSelectedSampleFromGithub, (args: SampleDownloadRequest) => rpcManger.downloadSelectedSampleFromGithub(args));
 }

workspaces/ballerina/ballerina-extension/src/rpc-managers/common/rpc-handler.ts

@@ -31,19 +31,24 @@ import {
     FileOrDirResponse,
     GoToSourceRequest,
     OpenExternalUrlRequest,
+    PackageTomlValues,
     RunExternalCommandRequest,
     RunExternalCommandResponse,
+    SampleDownloadRequest,
     ShowErrorMessageRequest,
     SyntaxTree,
-    PackageTomlValues,
     TypeResponse,
     WorkspaceFileRequest,
     WorkspaceRootResponse,
     WorkspacesFileResponse,
-    WorkspaceTypeResponse,
+    WorkspaceTypeResponse
 } from "@wso2/ballerina-core";
 import child_process from 'child_process';
-import { Uri, commands, env, window, workspace, MarkdownString } from "vscode";
+import path from "path";
+import os from "os";
+import fs from "fs";
+import * as unzipper from 'unzipper';
+import { commands, env, MarkdownString, ProgressLocation, Uri, window, workspace } from "vscode";
 import { URI } from "vscode-uri";
 import { extension } from "../../BalExtensionContext";
 import { StateMachine } from "../../stateMachine";
@@ -60,9 +65,11 @@ import {
     askFilePath,
     askProjectPath,
     BALLERINA_INTEGRATOR_ISSUES_URL,
-    getUpdatedSource
+    getUpdatedSource,
+    handleDownloadFile,
+    selectSampleDownloadPath
 } from "./utils";
-import path from "path";
+import { VisualizerWebview } from "../../views/visualizer/webview";
 
 export class CommonRpcManager implements CommonRPCAPI {
     async getTypeCompletions(): Promise<TypeResponse> {
@@ -304,4 +311,149 @@ export class CommonRpcManager implements CommonRPCAPI {
 
         return { type: "UNKNOWN" };
     }
+
+
+    async downloadSelectedSampleFromGithub(params: SampleDownloadRequest): Promise<boolean> {
+        const repoUrl = 'https://raw.githubusercontent.com/wso2/integration-samples/refs/heads/main/ballerina-integrator/samples/';
+        const rawFileLink = repoUrl + params.zipFileName + '.zip';
+        const defaultDownloadsPath = path.join(os.homedir(), 'Downloads'); // Construct the default downloads path
+        const pathFromDialog = await selectSampleDownloadPath();
+        if (pathFromDialog === "") {
+            return false;
+        }
+        const selectedPath = pathFromDialog === "" ? defaultDownloadsPath : pathFromDialog;
+        const filePath = path.join(selectedPath, params.zipFileName + '.zip');
+        let isSuccess = false;
+
+        if (fs.existsSync(filePath)) {
+            // already downloaded
+            isSuccess = true;
+        } else {
+            await window.withProgress({
+                location: ProgressLocation.Notification,
+                title: 'Downloading file',
+                cancellable: true
+            }, async (progress, cancellationToken) => {
+
+                let cancelled: boolean = false;
+                cancellationToken.onCancellationRequested(async () => {
+                    cancelled = true;
+                    // Clean up partial download
+                    if (fs.existsSync(filePath)) {
+                        fs.unlinkSync(filePath);
+                    }
+                });
+
+                try {
+                    await handleDownloadFile(rawFileLink, filePath, progress);
+                    isSuccess = true;
+                    return;
+                } catch (error) {
+                    window.showErrorMessage(`Error while downloading the file: ${error}`);
+                }
+            });
+        }
+
+        if (isSuccess) {
+            const successMsg = `The Integration sample file has been downloaded successfully to the following directory: ${filePath}.`;
+            const zipReadStream = fs.createReadStream(filePath);
+            if (fs.existsSync(path.join(selectedPath, params.zipFileName))) {
+                // already extracted
+                let uri = Uri.file(path.join(selectedPath, params.zipFileName));
+                commands.executeCommand("vscode.openFolder", uri, true);
+                return true;
+            }
+
+            let extractionError: Error | null = null;
+            const parseStream = unzipper.Parse();
+
+            // Handle errors on the read stream
+            zipReadStream.on("error", (error) => {
+                extractionError = error;
+                window.showErrorMessage(`Failed to read zip file: ${error.message}`);
+            });
+
+            // Handle errors on the parse stream
+            parseStream.on("error", (error) => {
+                extractionError = error;
+                window.showErrorMessage(`Failed to parse zip file. The file may be corrupted: ${error.message}`);
+            });
+
+            parseStream.on("entry", function (entry) {
+                // Skip processing if we've already encountered an error
+                if (extractionError) {
+                    entry.autodrain();
+                    return;
+                }
+
+                var isDir = entry.type === "Directory";
+                var fullpath = path.join(selectedPath, entry.path);
+                var directory = isDir ? fullpath : path.dirname(fullpath);
+
+                try {
+                    if (!fs.existsSync(directory)) {
+                        fs.mkdirSync(directory, { recursive: true });
+                    }
+                } catch (error) {
+                    extractionError = error as Error;
+                    window.showErrorMessage(`Failed to create directory "${directory}": ${error instanceof Error ? error.message : String(error)}`);
+                    entry.autodrain();
+                    return;
+                }
+
+                if (!isDir) {
+                    const writeStream = fs.createWriteStream(fullpath);
+
+                    // Handle write stream errors
+                    writeStream.on("error", (error) => {
+                        extractionError = error;
+                        window.showErrorMessage(`Failed to write file "${fullpath}": ${error.message}. This may be due to insufficient disk space or permission issues.`);
+                        entry.autodrain();
+                    });
+
+                    // Handle entry stream errors
+                    entry.on("error", (error) => {
+                        extractionError = error;
+                        window.showErrorMessage(`Failed to extract entry "${entry.path}": ${error.message}`);
+                        writeStream.destroy();
+                    });
+
+                    entry.pipe(writeStream);
+                }
+            });
+
+            parseStream.on("close", () => {
+                if (extractionError) {
+                    console.error("Extraction failed:", extractionError);
+                    window.showErrorMessage(`Sample extraction failed: ${extractionError.message}`);
+                    return;
+                }
+
+                console.log("Extraction complete!");
+                window.showInformationMessage('Where would you like to open the project?',
+                    { modal: true },
+                    'Current Window',
+                    'New Window'
+                ).then(selection => {
+                    if (selection === "Current Window") {
+                        // Dispose the current webview
+                        VisualizerWebview.currentPanel?.dispose();
+                        const folderUri = Uri.file(path.join(selectedPath, params.zipFileName));
+                        const workspaceFolders = workspace.workspaceFolders || [];
+                        if (!workspaceFolders.some(folder => folder.uri.fsPath === folderUri.fsPath)) {
+                            workspace.updateWorkspaceFolders(workspaceFolders.length, 0, { uri: folderUri });
+                        }
+                    } else if (selection === "New Window") {
+                        commands.executeCommand('vscode.openFolder', Uri.file(path.join(selectedPath, params.zipFileName)));
+                    }
+                });
+            });
+
+            zipReadStream.pipe(parseStream);
+            window.showInformationMessage(
+                successMsg,
+            );
+        }
+        return isSuccess;
+    }
 }