@mcp-abap-adt/core 2.5.0 → 2.5.2

package/dist/handlers/function/handleCheckFunctionModule.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * CheckFunctionModule Handler - Syntax check for ABAP function module via ADT API
+ *
+ * Uses checkFunctionModule from @mcp-abap-adt/adt-clients/core/functionModule for function module-specific checking.
+ * Requires function group name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCheckFunctionModule = handleCheckFunctionModule;
+const utils_1 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+const checkRunParser_1 = require("../../lib/checkRunParser");
+exports.TOOL_DEFINITION = {
+    name: "CheckFunctionModule",
+    description: "Perform syntax check on an ABAP function module. Returns syntax errors, warnings, and messages. Requires function group name. Can use session_id and session_state from GetSession to maintain the same session.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            function_group_name: {
+                type: "string",
+                description: "Function group name (e.g., Z_FUGR_TEST_0001)"
+            },
+            function_module_name: {
+                type: "string",
+                description: "Function module name (e.g., Z_TEST_FM)"
+            },
+            version: {
+                type: "string",
+                description: "Version to check: 'active' (last activated) or 'inactive' (current unsaved). Default: active",
+                enum: ["active", "inactive"]
+            },
+            session_id: {
+                type: "string",
+                description: "Session ID from GetSession. If not provided, a new session will be created."
+            },
+            session_state: {
+                type: "object",
+                description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.",
+                properties: {
+                    cookies: { type: "string" },
+                    csrf_token: { type: "string" },
+                    cookie_store: { type: "object" }
+                }
+            }
+        },
+        required: ["function_group_name", "function_module_name"]
+    }
+};
+/**
+ * Main handler for CheckFunctionModule MCP tool
+ */
+async function handleCheckFunctionModule(args) {
+    try {
+        const { function_group_name, function_module_name, version = 'active', session_id, session_state } = args;
+        if (!function_group_name || !function_module_name) {
+            return (0, utils_1.return_error)(new Error('function_group_name and function_module_name are required'));
+        }
+        const checkVersion = (version && ['active', 'inactive'].includes(version.toLowerCase()))
+            ? version.toLowerCase()
+            : 'active';
+        const connection = (0, utils_1.getManagedConnection)();
+        // Restore session state if provided
+        if (session_id && session_state) {
+            connection.setSessionState({
+                cookies: session_state.cookies || null,
+                csrfToken: session_state.csrf_token || null,
+                cookieStore: session_state.cookie_store || {}
+            });
+        }
+        else {
+            // Ensure connection is established
+            await connection.connect();
+        }
+        const functionGroupName = function_group_name.toUpperCase();
+        const functionModuleName = function_module_name.toUpperCase();
+        utils_1.logger.info(`Starting function module check: ${functionModuleName} in group ${functionGroupName} (version: ${checkVersion})`);
+        try {
+            const client = new adt_clients_1.CrudClient(connection);
+            await client.checkFunctionModule(functionModuleName, functionGroupName);
+            const response = client.getCheckResult();
+            if (!response) {
+                throw new Error('Function module check did not return a response');
+            }
+            // Parse check results
+            const checkResult = (0, checkRunParser_1.parseCheckRunResponse)(response);
+            // Get updated session state after check
+            const updatedSessionState = connection.getSessionState();
+            utils_1.logger.info(`✅ CheckFunctionModule completed: ${functionModuleName}`);
+            utils_1.logger.info(`   Status: ${checkResult.status}`);
+            utils_1.logger.info(`   Errors: ${checkResult.errors.length}, Warnings: ${checkResult.warnings.length}`);
+            return (0, utils_1.return_response)({
+                data: JSON.stringify({
+                    success: checkResult.success,
+                    function_group_name: functionGroupName,
+                    function_module_name: functionModuleName,
+                    version: checkVersion,
+                    check_result: checkResult,
+                    session_id: session_id,
+                    session_state: updatedSessionState ? {
+                        cookies: updatedSessionState.cookies,
+                        csrf_token: updatedSessionState.csrfToken,
+                        cookie_store: updatedSessionState.cookieStore
+                    } : null,
+                    message: checkResult.success
+                        ? `Function module ${functionModuleName} has no syntax errors`
+                        : `Function module ${functionModuleName} has ${checkResult.errors.length} error(s) and ${checkResult.warnings.length} warning(s)`
+                }, null, 2)
+            });
+        }
+        catch (error) {
+            utils_1.logger.error(`Error checking function module ${functionModuleName}:`, error);
+            let errorMessage = `Failed to check function module: ${error.message || String(error)}`;
+            if (error.response?.status === 404) {
+                errorMessage = `Function module ${functionModuleName} not found.`;
+            }
+            else if (error.response?.data && typeof error.response.data === 'string') {
+                try {
+                    const { XMLParser } = require('fast-xml-parser');
+                    const parser = new XMLParser({
+                        ignoreAttributes: false,
+                        attributeNamePrefix: '@_'
+                    });
+                    const errorData = parser.parse(error.response.data);
+                    const errorMsg = errorData['exc:exception']?.message?.['#text'] || errorData['exc:exception']?.message;
+                    if (errorMsg) {
+                        errorMessage = `SAP Error: ${errorMsg}`;
+                    }
+                }
+                catch (parseError) {
+                    // Ignore parse errors
+                }
+            }
+            return (0, utils_1.return_error)(new Error(errorMessage));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/function/handleCreateFunctionGroup.d.ts

@@ -0,0 +1,52 @@
+/**
+ * CreateFunctionGroup Handler - ABAP Function Group Creation via ADT API
+ *
+ * Uses FunctionGroupBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> create -> (activate)
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateFunctionGroup";
+    readonly description: "Create a new ABAP function group in SAP system. Function groups serve as containers for function modules. Uses stateful session for proper lock management.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly function_group_name: {
+                readonly type: "string";
+                readonly description: "Function group name (e.g., ZTEST_FG_001). Must follow SAP naming conventions (start with Z or Y, max 26 chars).";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Function group description. If not provided, function_group_name will be used.";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name (e.g., ZOK_LAB, $TMP for local objects)";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number (e.g., E19K905635). Required for transportable packages.";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate function group after creation. Default: true. Set to false for batch operations.";
+            };
+        };
+        readonly required: readonly ["function_group_name", "package_name"];
+    };
+};
+/**
+ * Main handler for CreateFunctionGroup MCP tool
+ *
+ * Uses FunctionGroupBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleCreateFunctionGroup(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCreateFunctionGroup.d.ts.map

package/dist/handlers/function/handleCreateFunctionGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateFunctionGroup.d.ts","sourceRoot":"","sources":["../../../src/handlers/function/handleCreateFunctionGroup.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlB,CAAC;AAUX;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE,GAAG;;;;;;GA+ExD"}

package/dist/handlers/function/handleCreateFunctionGroup.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * CreateFunctionGroup Handler - ABAP Function Group Creation via ADT API
+ *
+ * Uses FunctionGroupBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> create -> (activate)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCreateFunctionGroup = handleCreateFunctionGroup;
+const utils_1 = require("../../lib/utils");
+const transportValidation_js_1 = require("../../utils/transportValidation.js");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "CreateFunctionGroup",
+    description: "Create a new ABAP function group in SAP system. Function groups serve as containers for function modules. Uses stateful session for proper lock management.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            function_group_name: {
+                type: "string",
+                description: "Function group name (e.g., ZTEST_FG_001). Must follow SAP naming conventions (start with Z or Y, max 26 chars)."
+            },
+            description: {
+                type: "string",
+                description: "Function group description. If not provided, function_group_name will be used."
+            },
+            package_name: {
+                type: "string",
+                description: "Package name (e.g., ZOK_LAB, $TMP for local objects)"
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number (e.g., E19K905635). Required for transportable packages."
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate function group after creation. Default: true. Set to false for batch operations."
+            }
+        },
+        required: ["function_group_name", "package_name"]
+    }
+};
+/**
+ * Main handler for CreateFunctionGroup MCP tool
+ *
+ * Uses FunctionGroupBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleCreateFunctionGroup(args) {
+    try {
+        // Validate required parameters
+        if (!args?.function_group_name) {
+            return (0, utils_1.return_error)(new Error('function_group_name is required'));
+        }
+        if (!args?.package_name) {
+            return (0, utils_1.return_error)(new Error('package_name is required'));
+        }
+        // Validate transport_request: required for non-$TMP packages
+        try {
+            (0, transportValidation_js_1.validateTransportRequest)(args.package_name, args.transport_request);
+        }
+        catch (error) {
+            return (0, utils_1.return_error)(error);
+        }
+        const typedArgs = args;
+        const connection = (0, utils_1.getManagedConnection)();
+        const functionGroupName = typedArgs.function_group_name.toUpperCase();
+        utils_1.logger.info(`Starting function group creation: ${functionGroupName}`);
+        try {
+            // Create client
+            const client = new adt_clients_1.CrudClient(connection);
+            const shouldActivate = typedArgs.activate !== false; // Default to true if not specified
+            // Validate
+            await client.validateFunctionGroup(functionGroupName);
+            // Create
+            await client.createFunctionGroup(functionGroupName, typedArgs.description || functionGroupName, typedArgs.package_name, typedArgs.transport_request);
+            // Activate if requested
+            if (shouldActivate) {
+                await client.activateFunctionGroup(functionGroupName);
+            }
+            utils_1.logger.info(`✅ CreateFunctionGroup completed successfully: ${functionGroupName}`);
+            return (0, utils_1.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    function_group_name: functionGroupName,
+                    package_name: typedArgs.package_name,
+                    transport_request: typedArgs.transport_request || 'local',
+                    activated: shouldActivate,
+                    message: `Function group ${functionGroupName} created successfully${shouldActivate ? ' and activated' : ''}`
+                })
+            });
+        }
+        catch (error) {
+            utils_1.logger.error(`Error creating function group ${functionGroupName}:`, error);
+            // Check if function group already exists
+            if (error.message?.includes('already exists') || error.response?.status === 409) {
+                return (0, utils_1.return_error)(new Error(`Function group ${functionGroupName} already exists. Please delete it first or use a different name.`));
+            }
+            if (error.response?.status === 400) {
+                return (0, utils_1.return_error)(new Error(`Bad request. Check if function group name is valid and package exists.`));
+            }
+            const errorMessage = error.response?.data
+                ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+                : error.message || String(error);
+            return (0, utils_1.return_error)(new Error(`Failed to create function group ${functionGroupName}: ${errorMessage}`));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/function/handleCreateFunctionModule.d.ts

@@ -0,0 +1,57 @@
+/**
+ * CreateFunctionModule Handler - ABAP Function Module Creation via ADT API
+ *
+ * Uses FunctionModuleBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> create -> lock -> update -> check -> unlock -> (activate)
+ */
+export declare const TOOL_DEFINITION: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            function_group_name: {
+                type: string;
+                description: string;
+            };
+            function_module_name: {
+                type: string;
+                description: string;
+            };
+            source_code: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            transport_request: {
+                type: string;
+                description: string;
+            };
+            activate: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+/**
+ * Main handler for CreateFunctionModule MCP tool
+ *
+ * Uses FunctionModuleBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleCreateFunctionModule(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCreateFunctionModule.d.ts.map

package/dist/handlers/function/handleCreateFunctionModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateFunctionModule.d.ts","sourceRoot":"","sources":["../../../src/handlers/function/handleCreateFunctionModule.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC3B,CAAC;AAWF;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,GAAG;;;;;;GAsGzD"}

package/dist/handlers/function/handleCreateFunctionModule.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * CreateFunctionModule Handler - ABAP Function Module Creation via ADT API
+ *
+ * Uses FunctionModuleBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> create -> lock -> update -> check -> unlock -> (activate)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCreateFunctionModule = handleCreateFunctionModule;
+const utils_1 = require("../../lib/utils");
+const transportValidation_js_1 = require("../../utils/transportValidation.js");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "CreateFunctionModule",
+    description: "Create a new ABAP function module within an existing function group. Uses stateful session with LOCK/UNLOCK workflow for source code upload.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            function_group_name: {
+                type: "string",
+                description: "Parent function group name (e.g., ZTEST_FG_001)"
+            },
+            function_module_name: {
+                type: "string",
+                description: "Function module name (e.g., Z_TEST_FUNCTION_001). Must follow SAP naming conventions (start with Z or Y, max 30 chars)."
+            },
+            source_code: {
+                type: "string",
+                description: "ABAP source code for the function module including signature (FUNCTION name IMPORTING/EXPORTING ... ENDFUNCTION)."
+            },
+            description: {
+                type: "string",
+                description: "Optional description for the function module"
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number (e.g., E19K905635). Required for transportable packages."
+            },
+            activate: {
+                type: "boolean",
+                description: "Whether to activate the function module after creation (default: true)",
+                default: true
+            }
+        },
+        required: ["function_group_name", "function_module_name", "source_code"]
+    }
+};
+/**
+ * Main handler for CreateFunctionModule MCP tool
+ *
+ * Uses FunctionModuleBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleCreateFunctionModule(args) {
+    try {
+        // Validate required parameters
+        if (!args?.function_group_name) {
+            return (0, utils_1.return_error)(new Error('function_group_name is required'));
+        }
+        if (!args?.function_module_name) {
+            return (0, utils_1.return_error)(new Error('function_module_name is required'));
+        }
+        if (!args?.source_code) {
+            return (0, utils_1.return_error)(new Error('source_code is required'));
+        }
+        // Validate transport_request: required for non-$TMP packages
+        try {
+            (0, transportValidation_js_1.validateTransportRequest)(args.package_name, args.transport_request);
+        }
+        catch (error) {
+            return (0, utils_1.return_error)(error);
+        }
+        const typedArgs = args;
+        const connection = (0, utils_1.getManagedConnection)();
+        const functionGroupName = typedArgs.function_group_name.toUpperCase();
+        const functionModuleName = typedArgs.function_module_name.toUpperCase();
+        utils_1.logger.info(`Starting function module creation: ${functionModuleName} in ${functionGroupName}`);
+        try {
+            // Create client
+            const client = new adt_clients_1.CrudClient(connection);
+            const shouldActivate = typedArgs.activate !== false; // Default to true if not specified
+            // Validate
+            await client.validateFunctionModule(functionModuleName, functionGroupName);
+            // Create
+            // Note: Package name inherited from parent function group
+            await client.createFunctionModule(functionModuleName, functionGroupName, typedArgs.description || functionModuleName, '', // packageName inherited from function group
+            typedArgs.transport_request);
+            // Lock
+            await client.lockFunctionModule(functionModuleName, functionGroupName);
+            const lockHandle = client.getLockHandle();
+            // Update with source code
+            await client.updateFunctionModule(functionModuleName, functionGroupName, typedArgs.source_code, lockHandle);
+            // Check
+            await client.checkFunctionModule(functionModuleName, functionGroupName);
+            // Unlock
+            await client.unlockFunctionModule(functionModuleName, functionGroupName, lockHandle);
+            // Activate if requested
+            if (shouldActivate) {
+                await client.activateFunctionModule(functionModuleName, functionGroupName);
+            }
+            utils_1.logger.info(`✅ CreateFunctionModule completed successfully: ${functionModuleName}`);
+            return (0, utils_1.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    function_module_name: functionModuleName,
+                    function_group_name: functionGroupName,
+                    transport_request: typedArgs.transport_request || 'local',
+                    activated: shouldActivate,
+                    message: `Function module ${functionModuleName} created successfully${shouldActivate ? ' and activated' : ''}`
+                })
+            });
+        }
+        catch (error) {
+            utils_1.logger.error(`Error creating function module ${functionModuleName}:`, error);
+            // Check if function module already exists
+            if (error.message?.includes('already exists') || error.response?.status === 409) {
+                return (0, utils_1.return_error)(new Error(`Function module ${functionModuleName} already exists in group ${functionGroupName}. Please delete it first or use a different name.`));
+            }
+            if (error.response?.status === 404) {
+                return (0, utils_1.return_error)(new Error(`Function group ${functionGroupName} not found. Create the function group first.`));
+            }
+            if (error.response?.status === 400) {
+                return (0, utils_1.return_error)(new Error(`Bad request. Check if function module name is valid and function group exists.`));
+            }
+            const errorMessage = error.response?.data
+                ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+                : error.message || String(error);
+            return (0, utils_1.return_error)(new Error(`Failed to create function module ${functionModuleName}: ${errorMessage}`));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/function/handleGetFunction.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetFunction";
+    readonly description: "Retrieve ABAP Function Module source code.";
+    readonly inputSchema: {
+        readonly function_name: z.ZodString;
+        readonly function_group: z.ZodString;
+    };
+};
+export declare function handleGetFunction(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleGetFunction.d.ts.map

package/dist/handlers/function/handleGetFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetFunction.d.ts","sourceRoot":"","sources":["../../../src/handlers/function/handleGetFunction.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;;CAOlB,CAAC;AAsEX,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,GAAG;;;;;;GAsDhD"}