@mcp-abap-adt/core 2.5.0 → 2.5.2

package/dist/handlers/function/handleGetFunction.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetFunction = handleGetFunction;
+const utils_1 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const writeResultToFile_1 = require("../../lib/writeResultToFile");
+const z = __importStar(require("zod"));
+exports.TOOL_DEFINITION = {
+    name: "GetFunction",
+    description: "Retrieve ABAP Function Module source code.",
+    inputSchema: {
+        function_name: z.string().describe("Name of the function module"),
+        function_group: z.string().describe("Name of the function group")
+    }
+};
+function parseFunctionXml(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        parseAttributeValue: true,
+        trimValues: true
+    });
+    const result = parser.parse(xml);
+    // ADT Function Module XML (FUGR/FM)
+    if (result['fu:functionModule']) {
+        const f = result['fu:functionModule'];
+        // Parameter extraction helper
+        const params = (section) => {
+            const arr = f[section]?.['fu:parameter'];
+            if (!arr)
+                return [];
+            return Array.isArray(arr)
+                ? arr.map(p => ({
+                    name: p['fu:name'],
+                    type: p['fu:type'],
+                    typing: p['fu:typing'],
+                    reference: p['fu:reference'],
+                    default: p['fu:default'],
+                    optional: p['fu:optional'] === 'true',
+                    description: p['fu:description']
+                }))
+                : [{
+                        name: arr['fu:name'],
+                        type: arr['fu:type'],
+                        typing: arr['fu:typing'],
+                        reference: arr['fu:reference'],
+                        default: arr['fu:default'],
+                        optional: arr['fu:optional'] === 'true',
+                        description: arr['fu:description']
+                    }];
+        };
+        // Table parameters
+        const tables = params('fu:tables');
+        // Import/export/changing parameter sets
+        const importing = params('fu:importing');
+        const exporting = params('fu:exporting');
+        const changing = params('fu:changing');
+        // Exceptions
+        const exceptions = f['fu:exceptions']?.['fu:exception'];
+        const excArr = !exceptions ? [] : Array.isArray(exceptions)
+            ? exceptions.map(e => e['fu:name'])
+            : [exceptions['fu:name']];
+        // Source code
+        const source = f['fu:source'];
+        return {
+            name: f['adtcore:name'],
+            objectType: 'function_module',
+            description: f['adtcore:description'],
+            group: f['adtcore:parentRef']?.['adtcore:name'] || null,
+            importing,
+            exporting,
+            changing,
+            tables,
+            exceptions: excArr,
+            source
+        };
+    }
+    // fallback: return raw
+    return { raw: result };
+}
+async function handleGetFunction(args) {
+    try {
+        if (!args?.function_name || !args?.function_group) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Function name and group are required');
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.CrudClient(connection);
+        await client.readFunctionModule(args.function_name, args.function_group);
+        const response = client.getReadResult();
+        if (!response) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to read function module');
+        }
+        // Parse XML responses and return JSON; otherwise stream back the plain text
+        if (typeof response.data === 'string' && response.data.trim().startsWith('<?xml')) {
+            const resultObj = parseFunctionXml(response.data);
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(resultObj, null, 2)
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
+            }
+            return result;
+        }
+        else {
+            // Wrap plain text responses in the MCP format
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(response.data, args.filePath);
+            }
+            return {
+                isError: false,
+                content: [
+                    {
+                        type: "text",
+                        text: response.data
+                    }
+                ]
+            };
+        }
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: error instanceof Error ? error.message : String(error)
+                }
+            ]
+        };
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetFunctionGroup.d.ts","sourceRoot":"","sources":["../../../src/handlers/function/handleGetFunctionGroup.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AA+BX,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,GAAG;;;;;;GAsDrD"}

package/dist/handlers/function/handleGetFunctionGroup.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetFunctionGroup = handleGetFunctionGroup;
+const utils_1 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const writeResultToFile_1 = require("../../lib/writeResultToFile");
+const z = __importStar(require("zod"));
+exports.TOOL_DEFINITION = {
+    name: "GetFunctionGroup",
+    description: "Retrieve ABAP Function Group source code.",
+    inputSchema: {
+        function_group: z.string().describe("Name of the function group")
+    }
+};
+function parseFunctionGroupXml(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        parseAttributeValue: true,
+        trimValues: true
+    });
+    const result = parser.parse(xml);
+    // ADT Function Group XML (FUGR)
+    if (result['fu:functionGroup']) {
+        const fg = result['fu:functionGroup'];
+        const modules = fg['fu:functionModules']?.['fu:functionModule'];
+        const moduleArr = !modules ? [] : Array.isArray(modules)
+            ? modules.map(m => m['adtcore:name'])
+            : [modules['adtcore:name']];
+        return {
+            name: fg['adtcore:name'],
+            objectType: 'function_group',
+            description: fg['adtcore:description'],
+            package: fg['adtcore:packageRef']?.['adtcore:name'] || null,
+            functionModules: moduleArr
+        };
+    }
+    // fallback: return raw
+    return { raw: result };
+}
+async function handleGetFunctionGroup(args) {
+    try {
+        if (!args?.function_group) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Function Group is required');
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.CrudClient(connection);
+        await client.readFunctionGroup(args.function_group);
+        const response = client.getReadResult();
+        if (!response) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to read function group');
+        }
+        // Parse XML responses; otherwise return the payload unchanged
+        if (typeof response.data === 'string' && response.data.trim().startsWith('<?xml')) {
+            const resultObj = parseFunctionGroupXml(response.data);
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(resultObj, null, 2)
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
+            }
+            return result;
+        }
+        else {
+            const plainResult = {
+                isError: false,
+                content: [
+                    {
+                        type: "text",
+                        text: response.data
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(response.data, args.filePath);
+            }
+            return plainResult;
+        }
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: error instanceof Error ? error.message : String(error)
+                }
+            ]
+        };
+    }
+}

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

@@ -0,0 +1,54 @@
+/**
+ * UpdateFunctionModuleSource Handler - Update Existing ABAP Function Module Source Code
+ *
+ * Uses FunctionModuleBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> lock -> update -> check -> unlock -> (activate)
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "UpdateFunctionModuleSource";
+    readonly description: "Update source code of an existing ABAP function module. Locks the function module, uploads new source code, and unlocks. Optionally activates after update. Use this to modify existing function modules without re-creating metadata.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly function_group_name: {
+                readonly type: "string";
+                readonly description: "Function group name containing the function module (e.g., ZOK_FG_MCP01).";
+            };
+            readonly function_module_name: {
+                readonly type: "string";
+                readonly description: "Function module name (e.g., Z_TEST_FM_MCP01). Function module must already exist.";
+            };
+            readonly source_code: {
+                readonly type: "string";
+                readonly description: "Complete ABAP function module source code. Must include FUNCTION statement with parameters and ENDFUNCTION. Example:\n\nFUNCTION Z_TEST_FM\n  IMPORTING\n    VALUE(iv_input) TYPE string\n  EXPORTING\n    VALUE(ev_output) TYPE string.\n  \n  ev_output = iv_input.\nENDFUNCTION.";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number (e.g., E19K905635). Required for transportable function modules.";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate function module after source update. Default: false. Set to true to activate immediately.";
+            };
+        };
+        readonly required: readonly ["function_group_name", "function_module_name", "source_code"];
+    };
+};
+interface UpdateFunctionModuleSourceArgs {
+    function_group_name: string;
+    function_module_name: string;
+    source_code: string;
+    transport_request?: string;
+    activate?: boolean;
+}
+/**
+ * Main handler for UpdateFunctionModuleSource MCP tool
+ *
+ * Uses FunctionModuleBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleUpdateFunctionModuleSource(args: UpdateFunctionModuleSourceArgs): Promise<any>;
+export {};
+//# sourceMappingURL=handleUpdateFunctionModuleSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleUpdateFunctionModuleSource.d.ts","sourceRoot":"","sources":["../../../src/handlers/function/handleUpdateFunctionModuleSource.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlB,CAAC;AAEX,UAAU,8BAA8B;IACtC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAGD;;;;;GAKG;AACH,wBAAsB,gCAAgC,CAAC,IAAI,EAAE,8BAA8B,GAAG,OAAO,CAAC,GAAG,CAAC,CAkEzG"}

package/dist/handlers/function/handleUpdateFunctionModuleSource.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * UpdateFunctionModuleSource Handler - Update Existing ABAP Function Module Source Code
+ *
+ * Uses FunctionModuleBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> lock -> update -> check -> unlock -> (activate)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleUpdateFunctionModuleSource = handleUpdateFunctionModuleSource;
+const utils_1 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "UpdateFunctionModuleSource",
+    description: "Update source code of an existing ABAP function module. Locks the function module, uploads new source code, and unlocks. Optionally activates after update. Use this to modify existing function modules without re-creating metadata.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            function_group_name: {
+                type: "string",
+                description: "Function group name containing the function module (e.g., ZOK_FG_MCP01)."
+            },
+            function_module_name: {
+                type: "string",
+                description: "Function module name (e.g., Z_TEST_FM_MCP01). Function module must already exist."
+            },
+            source_code: {
+                type: "string",
+                description: "Complete ABAP function module source code. Must include FUNCTION statement with parameters and ENDFUNCTION. Example:\n\nFUNCTION Z_TEST_FM\n  IMPORTING\n    VALUE(iv_input) TYPE string\n  EXPORTING\n    VALUE(ev_output) TYPE string.\n  \n  ev_output = iv_input.\nENDFUNCTION."
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number (e.g., E19K905635). Required for transportable function modules."
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate function module after source update. Default: false. Set to true to activate immediately."
+            }
+        },
+        required: ["function_group_name", "function_module_name", "source_code"]
+    }
+};
+/**
+ * Main handler for UpdateFunctionModuleSource MCP tool
+ *
+ * Uses FunctionModuleBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleUpdateFunctionModuleSource(args) {
+    try {
+        // Validate inputs
+        if (!args.function_module_name || args.function_module_name.length > 30) {
+            return (0, utils_1.return_error)(new Error("Function module name is required and must not exceed 30 characters"));
+        }
+        if (!args.function_group_name || args.function_group_name.length > 30) {
+            return (0, utils_1.return_error)(new Error("Function group name is required and must not exceed 30 characters"));
+        }
+        if (!args.source_code) {
+            return (0, utils_1.return_error)(new Error("Source code is required"));
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const functionGroupName = args.function_group_name.toUpperCase();
+        const functionModuleName = args.function_module_name.toUpperCase();
+        utils_1.logger.info(`Starting function module source update: ${functionModuleName} in ${functionGroupName}`);
+        try {
+            const client = new adt_clients_1.CrudClient(connection);
+            const shouldActivate = args.activate === true;
+            // Execute operation chain: lock -> update -> check -> unlock -> (activate)
+            await client
+                .lockFunctionModule(functionModuleName, functionGroupName)
+                .then(c => c.updateFunctionModule(functionModuleName, functionGroupName, args.source_code))
+                .then(c => c.checkFunctionModule(functionModuleName, functionGroupName))
+                .then(c => c.unlockFunctionModule(functionModuleName, functionGroupName))
+                .then(c => shouldActivate ? c.activateFunctionModule(functionModuleName, functionGroupName) : Promise.resolve(c))
+                .catch(error => {
+                utils_1.logger.error('Function module update chain failed:', error);
+                throw error;
+            });
+            utils_1.logger.info(`✅ UpdateFunctionModuleSource completed successfully: ${functionModuleName}`);
+            const result = {
+                success: true,
+                function_module_name: functionModuleName,
+                function_group_name: functionGroupName,
+                activated: shouldActivate,
+                message: `Function module ${functionModuleName} source code updated successfully${shouldActivate ? ' and activated' : ''}`
+            };
+            return (0, utils_1.return_response)({
+                data: JSON.stringify(result, null, 2),
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: {}
+            });
+        }
+        catch (error) {
+            utils_1.logger.error(`Error updating function module source ${functionModuleName}:`, error);
+            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 update function module source: ${errorMessage}`));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}

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

@@ -0,0 +1,58 @@
+/**
+ * ValidateFunctionModule Handler - Validate ABAP function module name via ADT API
+ *
+ * Uses validateFunctionModuleName from @mcp-abap-adt/adt-clients/core/functionModule for function module-specific validation.
+ * Requires function group name.
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "ValidateFunctionModule";
+    readonly description: "Validate an ABAP function module name before creation. Checks if the name is valid and available. Requires function group name. Can use session_id and session_state from GetSession to maintain the same session.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly function_group_name: {
+                readonly type: "string";
+                readonly description: "Function group name (e.g., Z_FUGR_TEST_0001)";
+            };
+            readonly function_module_name: {
+                readonly type: "string";
+                readonly description: "Function module name to validate (e.g., Z_TEST_FM)";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Optional description for validation";
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Session ID from GetSession. If not provided, a new session will be created.";
+            };
+            readonly session_state: {
+                readonly type: "object";
+                readonly description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.";
+                readonly properties: {
+                    readonly cookies: {
+                        readonly type: "string";
+                    };
+                    readonly csrf_token: {
+                        readonly type: "string";
+                    };
+                    readonly cookie_store: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["function_group_name", "function_module_name"];
+    };
+};
+/**
+ * Main handler for ValidateFunctionModule MCP tool
+ */
+export declare function handleValidateFunctionModule(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleValidateFunctionModule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleValidateFunctionModule.d.ts","sourceRoot":"","sources":["../../../src/handlers/function/handleValidateFunctionModule.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkClB,CAAC;AAcX;;GAEG;AACH,wBAAsB,4BAA4B,CAAC,IAAI,EAAE,GAAG;;;;;;GAiG3D"}