@mcp-abap-adt/core 2.5.2 → 2.6.1

package/dist/handlers/common/handleLockObject.d.ts

@@ -1,57 +0,0 @@
-/**
- * LockObject Handler - Lock ABAP object for modification via ADT API
- *
- * Uses lock functions from @mcp-abap-adt/adt-clients/core for all operations.
- * Returns lock handle that must be used in subsequent requests with the same session_id.
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "LockObject";
-    readonly description: "Lock an ABAP object for modification. Returns lock handle that must be used in subsequent update/unlock operations with the same session_id. Use GetSession first to get a session_id, then use that session_id for lock, update, and unlock operations.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly object_name: {
-                readonly type: "string";
-                readonly description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE). For function modules, use format GROUP|FM_NAME";
-            };
-            readonly object_type: {
-                readonly type: "string";
-                readonly description: "Object type: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'";
-                readonly enum: readonly ["class", "program", "interface", "function_group", "function_module", "table", "structure", "view", "domain", "data_element", "package", "behavior_definition", "metadata_extension"];
-            };
-            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 ["object_name", "object_type"];
-    };
-};
-/**
- * Main handler for LockObject MCP tool
- *
- * Uses lock functions from @mcp-abap-adt/adt-clients/core for all operations
- */
-export declare function handleLockObject(args: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-//# sourceMappingURL=handleLockObject.d.ts.map

package/dist/handlers/common/handleLockObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleLockObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/common/handleLockObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BlB,CAAC;AAaX;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,GAAG;;;;;;GAgK/C"}

package/dist/handlers/common/handleLockObject.js

@@ -1,195 +0,0 @@
-"use strict";
-/**
- * LockObject Handler - Lock ABAP object for modification via ADT API
- *
- * Uses lock functions from @mcp-abap-adt/adt-clients/core for all operations.
- * Returns lock handle that must be used in subsequent requests with the same session_id.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleLockObject = handleLockObject;
-const utils_1 = require("../../lib/utils");
-const sessionUtils_1 = require("../../lib/sessionUtils");
-const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
-exports.TOOL_DEFINITION = {
-    name: "LockObject",
-    description: "Lock an ABAP object for modification. Returns lock handle that must be used in subsequent update/unlock operations with the same session_id. Use GetSession first to get a session_id, then use that session_id for lock, update, and unlock operations.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            object_name: {
-                type: "string",
-                description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE). For function modules, use format GROUP|FM_NAME"
-            },
-            object_type: {
-                type: "string",
-                description: "Object type: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'",
-                enum: ["class", "program", "interface", "function_group", "function_module", "table", "structure", "view", "domain", "data_element", "package", "behavior_definition", "metadata_extension"]
-            },
-            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: ["object_name", "object_type"]
-    }
-};
-/**
- * Main handler for LockObject MCP tool
- *
- * Uses lock functions from @mcp-abap-adt/adt-clients/core for all operations
- */
-async function handleLockObject(args) {
-    try {
-        const { object_name, object_type, session_id, session_state } = args;
-        // Validation
-        if (!object_name || !object_type) {
-            return (0, utils_1.return_error)(new Error('object_name and object_type are required'));
-        }
-        const validTypes = ['class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package'];
-        if (!validTypes.includes(object_type.toLowerCase())) {
-            return (0, utils_1.return_error)(new Error(`Invalid object_type. Must be one of: ${validTypes.join(', ')}`));
-        }
-        const connection = (0, utils_1.getManagedConnection)();
-        const client = new adt_clients_1.CrudClient(connection);
-        // 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();
-        }
-        // Use provided session_id or generate new one
-        const desiredSessionId = session_id || (0, sessionUtils_1.generateSessionId)();
-        const objectName = object_name.toUpperCase();
-        const objectType = object_type.toLowerCase();
-        utils_1.logger.info(`Starting object lock: ${objectName} (type: ${objectType}, session: ${desiredSessionId.substring(0, 8)}...)`);
-        try {
-            let lockHandle;
-            // Call appropriate lock method based on object type
-            switch (objectType) {
-                case 'class':
-                    await client.lockClass(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'program':
-                    await client.lockProgram(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'interface':
-                    await client.lockInterface(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'function_group':
-                    await client.lockFunctionGroup(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'function_module':
-                    // Function module requires function group name which is not provided in this generic handler
-                    return (0, utils_1.return_error)(new Error('Function module locking via LockObject is not supported. Function modules require function group name.'));
-                case 'table':
-                    await client.lockTable(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'structure':
-                    await client.lockStructure(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'view':
-                    await client.lockView(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'domain':
-                    await client.lockDomain(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'data_element':
-                    await client.lockDataElement(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'behavior_definition':
-                    await client.lockBehaviorDefinition(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'metadata_extension':
-                    await client.lockMetadataExtension(objectName);
-                    lockHandle = client.getLockHandle();
-                    break;
-                case 'package':
-                    // Package requires superPackage parameter - need to fetch it or handle differently
-                    return (0, utils_1.return_error)(new Error('Package locking via LockObject is not supported. Use specific package operations.'));
-                default:
-                    return (0, utils_1.return_error)(new Error(`Unsupported object_type: ${object_type}`));
-            }
-            if (!lockHandle) {
-                throw new Error(`Lock did not return a lock handle for object ${objectName}`);
-            }
-            // Get updated session state after lock
-            const updatedSessionState = connection.getSessionState();
-            utils_1.logger.info(`✅ LockObject completed: ${objectName}`);
-            utils_1.logger.info(`   Lock handle: ${lockHandle.substring(0, 20)}...`);
-            return (0, utils_1.return_response)({
-                data: JSON.stringify({
-                    success: true,
-                    object_name: objectName,
-                    object_type: objectType,
-                    session_id: desiredSessionId,
-                    lock_handle: lockHandle,
-                    transport_request: null, // CrudClient doesn't expose transport request
-                    session_state: updatedSessionState ? {
-                        cookies: updatedSessionState.cookies,
-                        csrf_token: updatedSessionState.csrfToken,
-                        cookie_store: updatedSessionState.cookieStore
-                    } : null,
-                    message: `Object ${objectName} locked successfully. Use this lock_handle and session_id for subsequent update/unlock operations.`
-                }, null, 2)
-            });
-        }
-        catch (error) {
-            utils_1.logger.error(`Error locking object ${objectName}:`, error);
-            // Parse error message
-            let errorMessage = `Failed to lock object: ${error.message || String(error)}`;
-            if (error.response?.status === 404) {
-                errorMessage = `Object ${objectName} not found.`;
-            }
-            else if (error.response?.status === 409) {
-                errorMessage = `Object ${objectName} is already locked by another user.`;
-            }
-            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/common/handleUnlockObject.d.ts

@@ -1,61 +0,0 @@
-/**
- * UnlockObject Handler - Unlock ABAP object after modification via ADT API
- *
- * Uses unlock functions from @mcp-abap-adt/adt-clients/core for all operations.
- * Must use the same session_id and lock_handle from the LockObject operation.
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "UnlockObject";
-    readonly description: "Unlock an ABAP object after modification. Must use the same session_id and lock_handle from the LockObject operation.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly object_name: {
-                readonly type: "string";
-                readonly description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE). For function modules, use format GROUP|FM_NAME";
-            };
-            readonly object_type: {
-                readonly type: "string";
-                readonly description: "Object type: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'";
-                readonly enum: readonly ["class", "program", "interface", "function_group", "function_module", "table", "structure", "view", "domain", "data_element", "package", "behavior_definition", "metadata_extension"];
-            };
-            readonly lock_handle: {
-                readonly type: "string";
-                readonly description: "Lock handle from LockObject operation";
-            };
-            readonly session_id: {
-                readonly type: "string";
-                readonly description: "Session ID from LockObject operation. Must be the same as used in LockObject.";
-            };
-            readonly session_state: {
-                readonly type: "object";
-                readonly description: "Session state from LockObject (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 ["object_name", "object_type", "lock_handle", "session_id"];
-    };
-};
-/**
- * Main handler for UnlockObject MCP tool
- *
- * Uses unlock functions from @mcp-abap-adt/adt-clients/core for all operations
- */
-export declare function handleUnlockObject(args: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-//# sourceMappingURL=handleUnlockObject.d.ts.map

package/dist/handlers/common/handleUnlockObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleUnlockObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/common/handleUnlockObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmClB,CAAC;AAcX;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;;;;;;GA2IjD"}

package/dist/handlers/common/handleUnlockObject.js

@@ -1,178 +0,0 @@
-"use strict";
-/**
- * UnlockObject Handler - Unlock ABAP object after modification via ADT API
- *
- * Uses unlock functions from @mcp-abap-adt/adt-clients/core for all operations.
- * Must use the same session_id and lock_handle from the LockObject operation.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleUnlockObject = handleUnlockObject;
-const utils_1 = require("../../lib/utils");
-const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
-exports.TOOL_DEFINITION = {
-    name: "UnlockObject",
-    description: "Unlock an ABAP object after modification. Must use the same session_id and lock_handle from the LockObject operation.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            object_name: {
-                type: "string",
-                description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE). For function modules, use format GROUP|FM_NAME"
-            },
-            object_type: {
-                type: "string",
-                description: "Object type: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'",
-                enum: ["class", "program", "interface", "function_group", "function_module", "table", "structure", "view", "domain", "data_element", "package", "behavior_definition", "metadata_extension"]
-            },
-            lock_handle: {
-                type: "string",
-                description: "Lock handle from LockObject operation"
-            },
-            session_id: {
-                type: "string",
-                description: "Session ID from LockObject operation. Must be the same as used in LockObject."
-            },
-            session_state: {
-                type: "object",
-                description: "Session state from LockObject (cookies, csrf_token, cookie_store). Required if session_id is provided.",
-                properties: {
-                    cookies: { type: "string" },
-                    csrf_token: { type: "string" },
-                    cookie_store: { type: "object" }
-                }
-            }
-        },
-        required: ["object_name", "object_type", "lock_handle", "session_id"]
-    }
-};
-/**
- * Main handler for UnlockObject MCP tool
- *
- * Uses unlock functions from @mcp-abap-adt/adt-clients/core for all operations
- */
-async function handleUnlockObject(args) {
-    try {
-        const { object_name, object_type, lock_handle, session_id, session_state } = args;
-        // Validation
-        if (!object_name || !object_type || !lock_handle || !session_id) {
-            return (0, utils_1.return_error)(new Error('object_name, object_type, lock_handle, and session_id are required'));
-        }
-        const validTypes = ['class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'package', 'behavior_definition', 'metadata_extension'];
-        if (!validTypes.includes(object_type.toLowerCase())) {
-            return (0, utils_1.return_error)(new Error(`Invalid object_type. Must be one of: ${validTypes.join(', ')}`));
-        }
-        const connection = (0, utils_1.getManagedConnection)();
-        const client = new adt_clients_1.CrudClient(connection);
-        // Restore session state if provided
-        if (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 objectName = object_name.toUpperCase();
-        const objectType = object_type.toLowerCase();
-        utils_1.logger.info(`Starting object unlock: ${objectName} (type: ${objectType}, session: ${session_id.substring(0, 8)}...)`);
-        try {
-            // Call appropriate unlock method based on object type
-            switch (objectType) {
-                case 'class':
-                    await client.unlockClass(objectName, lock_handle);
-                    break;
-                case 'program':
-                    await client.unlockProgram(objectName, lock_handle);
-                    break;
-                case 'interface':
-                    await client.unlockInterface(objectName, lock_handle);
-                    break;
-                case 'function_group':
-                    await client.unlockFunctionGroup(objectName, lock_handle);
-                    break;
-                case 'function_module':
-                    // Function module requires function group name which is not provided in this generic handler
-                    return (0, utils_1.return_error)(new Error('Function module unlocking via UnlockObject is not supported. Function modules require function group name.'));
-                case 'table':
-                    await client.unlockTable(objectName, lock_handle);
-                    break;
-                case 'structure':
-                    await client.unlockStructure(objectName, lock_handle);
-                    break;
-                case 'view':
-                    await client.unlockView(objectName, lock_handle);
-                    break;
-                case 'domain':
-                    await client.unlockDomain(objectName, lock_handle);
-                    break;
-                case 'data_element':
-                    await client.unlockDataElement(objectName, lock_handle);
-                    break;
-                case 'behavior_definition':
-                    await client.unlockBehaviorDefinition(objectName, lock_handle);
-                    break;
-                case 'metadata_extension':
-                    await client.unlockMetadataExtension(objectName, lock_handle);
-                    break;
-                case 'package':
-                    // Package requires superPackage parameter - need to fetch it or handle differently
-                    return (0, utils_1.return_error)(new Error('Package unlocking via UnlockObject is not supported. Use specific package operations.'));
-                default:
-                    return (0, utils_1.return_error)(new Error(`Unsupported object_type: ${object_type}`));
-            }
-            // Get updated session state after unlock
-            const updatedSessionState = connection.getSessionState();
-            utils_1.logger.info(`✅ UnlockObject completed: ${objectName}`);
-            return (0, utils_1.return_response)({
-                data: JSON.stringify({
-                    success: true,
-                    object_name: objectName,
-                    object_type: objectType,
-                    session_id: session_id,
-                    session_state: updatedSessionState ? {
-                        cookies: updatedSessionState.cookies,
-                        csrf_token: updatedSessionState.csrfToken,
-                        cookie_store: updatedSessionState.cookieStore
-                    } : null,
-                    message: `Object ${objectName} unlocked successfully.`
-                }, null, 2)
-            });
-        }
-        catch (error) {
-            utils_1.logger.error(`Error unlocking object ${objectName}:`, error);
-            // Parse error message
-            let errorMessage = `Failed to unlock object: ${error.message || String(error)}`;
-            if (error.response?.status === 404) {
-                errorMessage = `Object ${objectName} not found.`;
-            }
-            else if (error.response?.status === 400) {
-                errorMessage = `Invalid lock handle or session. Make sure you're using the same session_id and lock_handle from LockObject.`;
-            }
-            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/common/handleValidateObject.d.ts

@@ -1,58 +0,0 @@
-/**
- * ValidateObject Handler - Validate ABAP object name via ADT API
- *
- * Uses validateObjectName from @mcp-abap-adt/adt-clients/core for all operations.
- * Connection management handled internally.
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "ValidateObject";
-    readonly description: "Validate an ABAP object name before creation. Checks if the name is valid and available. Returns validation result with success status and message. Can use session_id and session_state from GetSession to maintain the same session.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly object_name: {
-                readonly type: "string";
-                readonly description: "Object name to validate (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE)";
-            };
-            readonly object_type: {
-                readonly type: "string";
-                readonly description: "Object type: 'class', 'program', 'interface', 'function_group', 'table', 'structure', 'view', 'domain', 'data_element', 'package'";
-                readonly enum: readonly ["class", "program", "interface", "function_group", "table", "structure", "view", "domain", "data_element", "package"];
-            };
-            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 ["object_name", "object_type"];
-    };
-};
-/**
- * Main handler for ValidateObject MCP tool
- *
- * Uses validateObjectName from @mcp-abap-adt/adt-clients/core for all operations
- * Connection management handled internally
- */
-export declare function handleValidateObject(args: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-//# sourceMappingURL=handleValidateObject.d.ts.map

package/dist/handlers/common/handleValidateObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleValidateObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/common/handleValidateObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BlB,CAAC;AAaX;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG;;;;;;GA8InD"}