@mcp-abap-adt/core 2.5.2 → 2.7.0

package/dist/handlers/function/handleCheckFunctionModule.js

@@ -1,140 +0,0 @@
-"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

@@ -1,52 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,114 +0,0 @@
-"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

@@ -1,57 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,137 +0,0 @@
-"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

@@ -1,17 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}