@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/common/handleActivateObject.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * ActivateObject Handler - Universal ABAP Object Activation via ADT API
+ *
+ * Uses activateObjectsGroup and parseActivationResponse from @mcp-abap-adt/adt-clients/core for all operations.
+ * Connection management handled internally.
+ *
+ * Activates one or multiple ABAP repository objects using ADT activation endpoint.
+ * This is a stateless operation - no session management or locking required.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleActivateObject = handleActivateObject;
+const utils_1 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "ActivateObject",
+    description: "Activate one or multiple ABAP repository objects. Works with any object type: classes, programs, tables, views, domains, data elements, etc. URI is auto-generated from name and type. Returns activation status and any warnings/errors.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            objects: {
+                type: "array",
+                description: "Array of objects to activate. Each object must have 'name' and 'type'. URI is auto-generated.",
+                items: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Object name in uppercase (e.g., 'ZCL_MY_CLASS', 'Z_MY_PROGRAM', 'ZOK_I_MARKET_0001')"
+                        },
+                        type: {
+                            type: "string",
+                            description: "Object type code (e.g., 'CLAS/OC', 'PROG/P', 'DDLS/DF', 'TABL/DT'). URI will be auto-generated from this."
+                        },
+                        uri: {
+                            type: "string",
+                            description: "Optional: Object URI in ADT format. If not provided, will be auto-generated from name and type."
+                        }
+                    },
+                    required: ["name", "type"]
+                }
+            },
+            preaudit: {
+                type: "boolean",
+                description: "Request pre-audit before activation. Default: true"
+            }
+        },
+        required: ["objects"]
+    }
+};
+/**
+ * Main handler for ActivateObject MCP tool
+ *
+ * Uses activateObjectsGroup and parseActivationResponse from @mcp-abap-adt/adt-clients/core for all operations
+ * Connection management handled internally
+ *
+ * This is a stateless operation - no session management needed.
+ * Activation endpoint handles multiple objects in one request.
+ */
+async function handleActivateObject(params) {
+    try {
+        const args = params;
+        // Validate required parameters
+        if (!args.objects || !Array.isArray(args.objects) || args.objects.length === 0) {
+            return (0, utils_1.return_error)(new Error("Missing required parameter: objects (must be non-empty array)"));
+        }
+        // Validate each object has required properties
+        for (const obj of args.objects) {
+            if (!obj.name) {
+                return (0, utils_1.return_error)(new Error("Each object must have 'name' property"));
+            }
+            if (!obj.uri && !obj.type) {
+                utils_1.logger.warn(`Object ${obj.name} has no URI or type, will attempt to guess from name`);
+            }
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const preaudit = args.preaudit !== false; // Default: true
+        const client = new adt_clients_1.CrudClient(connection);
+        utils_1.logger.info(`Starting activation of ${args.objects.length} object(s)`);
+        try {
+            // Prepare objects for group activation
+            const activationObjects = args.objects.map(obj => ({
+                type: obj.type,
+                name: obj.name.toUpperCase()
+            }));
+            utils_1.logger.debug('Activating objects:', activationObjects);
+            // Make group activation request using CrudClient
+            const response = await client.activateObjectsGroup(activationObjects, preaudit);
+            // Debug: log raw response
+            utils_1.logger.debug('Activation response status:', response.status);
+            utils_1.logger.debug('Activation response data:', typeof response.data === 'string' ? response.data.substring(0, 500) : response.data);
+            // Parse response
+            const activationResult = client.parseActivationResponse(response.data);
+            const success = activationResult.activated && activationResult.checked;
+            // Build result object
+            const result = {
+                success,
+                objects_count: args.objects.length,
+                objects: activationObjects.map((obj, idx) => ({
+                    name: obj.name,
+                    uri: args.objects[idx].uri,
+                    type: args.objects[idx].type
+                })),
+                activation: {
+                    activated: activationResult.activated,
+                    checked: activationResult.checked,
+                    generated: activationResult.generated
+                },
+                messages: activationResult.messages,
+                warnings: activationResult.messages.filter(m => m.type === 'warning' || m.type === 'W'),
+                errors: activationResult.messages.filter(m => m.type === 'error' || m.type === 'E'),
+                message: success
+                    ? `Successfully activated ${args.objects.length} object(s)`
+                    : `Activation completed with issues: ${activationResult.messages.length} message(s)`
+            };
+            utils_1.logger.info(`Activation completed: ${success ? 'SUCCESS' : 'WITH ISSUES'}`);
+            return (0, utils_1.return_response)({
+                data: JSON.stringify(result, null, 2),
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: {}
+            });
+        }
+        catch (error) {
+            const errorMessage = error.response?.data
+                ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+                : error.message || String(error);
+            utils_1.logger.error(`Activation failed:`, errorMessage);
+            return (0, utils_1.return_error)(new Error(`Failed to activate objects: ${errorMessage}`));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}

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

@@ -0,0 +1,63 @@
+/**
+ * CheckObject Handler - Syntax check for ABAP objects via ADT API
+ *
+ * Uses runCheckRun and parseCheckRunResponse from @mcp-abap-adt/adt-clients/core for all operations.
+ * Connection management handled internally.
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "CheckObject";
+    readonly description: "Perform syntax check on an ABAP object without activation. Returns syntax errors, warnings, and messages. Useful for validation during development. 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 (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', 'behavior_definition', 'metadata_extension'";
+                readonly enum: readonly ["class", "program", "interface", "function_group", "table", "structure", "view", "domain", "data_element", "behavior_definition", "metadata_extension"];
+            };
+            readonly version: {
+                readonly type: "string";
+                readonly description: "Version to check: 'active' (last activated) or 'inactive' (current unsaved). Default: active";
+                readonly enum: readonly ["active", "inactive"];
+            };
+            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 CheckObject MCP tool
+ *
+ * Uses runCheckRun and parseCheckRunResponse from @mcp-abap-adt/adt-clients/core for all operations
+ * Connection management handled internally
+ */
+export declare function handleCheckObject(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCheckObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleCheckObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/common/handleCheckObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoClB,CAAC;AAeX;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,GAAG;;;;;;GA+JhD"}

package/dist/handlers/common/handleCheckObject.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * CheckObject Handler - Syntax check for ABAP objects via ADT API
+ *
+ * Uses runCheckRun and parseCheckRunResponse from @mcp-abap-adt/adt-clients/core for all operations.
+ * Connection management handled internally.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCheckObject = handleCheckObject;
+const utils_1 = require("../../lib/utils");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+const checkRunParser_1 = require("../../lib/checkRunParser");
+exports.TOOL_DEFINITION = {
+    name: "CheckObject",
+    description: "Perform syntax check on an ABAP object without activation. Returns syntax errors, warnings, and messages. Useful for validation during development. Can use session_id and session_state from GetSession to maintain the same session.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            object_name: {
+                type: "string",
+                description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, ZIF_MY_INTERFACE)"
+            },
+            object_type: {
+                type: "string",
+                description: "Object type: 'class', 'program', 'interface', 'function_group', 'table', 'structure', 'view', 'domain', 'data_element', 'behavior_definition', 'metadata_extension'",
+                enum: ["class", "program", "interface", "function_group", "table", "structure", "view", "domain", "data_element", "behavior_definition", "metadata_extension"]
+            },
+            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: ["object_name", "object_type"]
+    }
+};
+/**
+ * Main handler for CheckObject MCP tool
+ *
+ * Uses runCheckRun and parseCheckRunResponse from @mcp-abap-adt/adt-clients/core for all operations
+ * Connection management handled internally
+ */
+async function handleCheckObject(args) {
+    try {
+        const { object_name, object_type, version = 'active', 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', 'table', 'structure', 'view', 'domain', 'data_element', '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 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 objectName = object_name.toUpperCase();
+        utils_1.logger.info(`Starting object check: ${objectName} (type: ${object_type}, version: ${checkVersion})`);
+        try {
+            const client = new adt_clients_1.CrudClient(connection);
+            let response;
+            // Call appropriate check method based on object type
+            switch (object_type.toLowerCase()) {
+                case 'class':
+                    await client.checkClass(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'program':
+                    await client.checkProgram(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'interface':
+                    await client.checkInterface(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'function_group':
+                    await client.checkFunctionGroup(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'table':
+                    await client.checkTable(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'structure':
+                    await client.checkStructure(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'view':
+                    await client.checkView(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'domain':
+                    await client.checkDomain(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'data_element':
+                    await client.checkDataElement(objectName);
+                    response = client.getCheckResult();
+                    break;
+                case 'behavior_definition':
+                    await client.checkBehaviorDefinition(objectName, checkVersion);
+                    response = client.getCheckResult();
+                    break;
+                case 'metadata_extension':
+                    await client.checkMetadataExtension(objectName, checkVersion);
+                    response = client.getCheckResult();
+                    break;
+                default:
+                    return (0, utils_1.return_error)(new Error(`Unsupported object_type: ${object_type}`));
+            }
+            if (!response) {
+                throw new Error(`Check did not return a response for object ${objectName}`);
+            }
+            // Parse check results
+            const checkResult = (0, checkRunParser_1.parseCheckRunResponse)(response);
+            // Get updated session state after check
+            const updatedSessionState = connection.getSessionState();
+            utils_1.logger.info(`✅ CheckObject completed: ${objectName}`);
+            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,
+                    object_name: objectName,
+                    object_type,
+                    version: checkVersion,
+                    check_result: checkResult,
+                    session_id: session_id || null,
+                    session_state: updatedSessionState ? {
+                        cookies: updatedSessionState.cookies,
+                        csrf_token: updatedSessionState.csrfToken,
+                        cookie_store: updatedSessionState.cookieStore
+                    } : null,
+                    message: checkResult.success
+                        ? `Object ${objectName} has no syntax errors`
+                        : `Object ${objectName} has ${checkResult.errors.length} error(s) and ${checkResult.warnings.length} warning(s)`
+                }, null, 2)
+            });
+        }
+        catch (error) {
+            utils_1.logger.error(`Error checking object ${objectName}:`, error);
+            // Parse error message
+            let errorMessage = `Failed to check object: ${error.message || String(error)}`;
+            if (error.response?.status === 404) {
+                errorMessage = `Object ${objectName} not found.`;
+            }
+            else if (error.response?.data && typeof error.response.data === 'string') {
+                try {
+                    const parser = new fast_xml_parser_1.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/handleDeleteObject.d.ts

@@ -0,0 +1,46 @@
+/**
+ * DeleteObject Handler - Delete ABAP objects via ADT API
+ *
+ * Uses deleteObject function from @mcp-abap-adt/adt-clients for all operations.
+ * Connection management handled internally.
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "DeleteObject";
+    readonly description: "Delete an ABAP object from the SAP system via ADT deletion API. Object URI is built automatically from object_name and object_type. Transport request optional for $TMP objects.";
+    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, Z_TEST_FM_MCP01)";
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly description: "Object type: 'CLAS/OC' (class), 'PROG/P' (program), 'INTF/OI' (interface), 'FUGR/F' (function group), 'FUGR/FF' (function module), 'TABL/DT' (table), 'TTYP/ST' (structure), 'DDLS/DF' (view), 'DTEL/DE' (data element), 'DOMA/DM' (domain), 'BDEF/BD' (behavior definition), 'DDLX/EX' (metadata extension). Or simplified: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'behavior_definition', 'metadata_extension'";
+            };
+            readonly function_group_name: {
+                readonly type: "string";
+                readonly description: "Required only for function_module type - name of the function group containing the module";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number (e.g., E19K905635). Required for transportable objects. Optional for local objects ($TMP).";
+            };
+        };
+        readonly required: readonly ["object_name", "object_type"];
+    };
+};
+/**
+ * Main handler for DeleteObject MCP tool
+ *
+ * Uses deleteObject function from @mcp-abap-adt/adt-clients for all operations
+ * Connection management handled internally
+ */
+export declare function handleDeleteObject(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleDeleteObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleDeleteObject.d.ts","sourceRoot":"","sources":["../../../src/handlers/common/handleDeleteObject.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAC;AAUX;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;;;;;;GA8IjD"}

package/dist/handlers/common/handleDeleteObject.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * DeleteObject Handler - Delete ABAP objects via ADT API
+ *
+ * Uses deleteObject function from @mcp-abap-adt/adt-clients for all operations.
+ * Connection management handled internally.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleDeleteObject = handleDeleteObject;
+const utils_1 = require("../../lib/utils");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "DeleteObject",
+    description: "Delete an ABAP object from the SAP system via ADT deletion API. Object URI is built automatically from object_name and object_type. Transport request optional for $TMP objects.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            object_name: {
+                type: "string",
+                description: "Object name (e.g., ZCL_MY_CLASS, Z_MY_PROGRAM, Z_TEST_FM_MCP01)"
+            },
+            object_type: {
+                type: "string",
+                description: "Object type: 'CLAS/OC' (class), 'PROG/P' (program), 'INTF/OI' (interface), 'FUGR/F' (function group), 'FUGR/FF' (function module), 'TABL/DT' (table), 'TTYP/ST' (structure), 'DDLS/DF' (view), 'DTEL/DE' (data element), 'DOMA/DM' (domain), 'BDEF/BD' (behavior definition), 'DDLX/EX' (metadata extension). Or simplified: 'class', 'program', 'interface', 'function_group', 'function_module', 'table', 'structure', 'view', 'domain', 'data_element', 'behavior_definition', 'metadata_extension'"
+            },
+            function_group_name: {
+                type: "string",
+                description: "Required only for function_module type - name of the function group containing the module"
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number (e.g., E19K905635). Required for transportable objects. Optional for local objects ($TMP)."
+            }
+        },
+        required: ["object_name", "object_type"]
+    }
+};
+/**
+ * Main handler for DeleteObject MCP tool
+ *
+ * Uses deleteObject function from @mcp-abap-adt/adt-clients for all operations
+ * Connection management handled internally
+ */
+async function handleDeleteObject(args) {
+    try {
+        const { object_name, object_type, function_group_name, transport_request } = args;
+        // Validation
+        if (!object_name || !object_type) {
+            return (0, utils_1.return_error)(new Error('object_name and object_type are required'));
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const crudClient = new adt_clients_1.CrudClient(connection);
+        const objectName = object_name.toUpperCase();
+        utils_1.logger.info(`Starting object deletion: ${objectName} (type: ${object_type})`);
+        try {
+            let response;
+            // Call appropriate delete method based on object type
+            switch (object_type.toLowerCase()) {
+                case 'class':
+                case 'clas/oc':
+                    await crudClient.deleteClass(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'program':
+                case 'prog/p':
+                    await crudClient.deleteProgram(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'interface':
+                case 'intf/oi':
+                    await crudClient.deleteInterface(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'function_group':
+                case 'fugr/f':
+                    await crudClient.deleteFunctionGroup(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'function_module':
+                case 'fugr/ff':
+                    if (!function_group_name) {
+                        return (0, utils_1.return_error)(new Error('function_group_name is required for function_module deletion'));
+                    }
+                    await crudClient.deleteFunctionModule(objectName, function_group_name, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'table':
+                case 'tabl/dt':
+                    await crudClient.deleteTable(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'structure':
+                case 'ttyp/st':
+                    await crudClient.deleteStructure(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'view':
+                case 'ddls/df':
+                    await crudClient.deleteView(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'domain':
+                case 'doma/dm':
+                    await crudClient.deleteDomain(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'data_element':
+                case 'dtel/de':
+                    await crudClient.deleteDataElement(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'package':
+                case 'devc/k':
+                    await crudClient.deletePackage(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'behavior_definition':
+                case 'bdef/bd':
+                    await crudClient.deleteBehaviorDefinition(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                case 'metadata_extension':
+                case 'ddlx/ex':
+                    await crudClient.deleteMetadataExtension(objectName, transport_request);
+                    response = crudClient.getDeleteResult();
+                    break;
+                default:
+                    return (0, utils_1.return_error)(new Error(`Unsupported object_type: ${object_type}`));
+            }
+            if (!response) {
+                throw new Error(`Delete did not return a response for object ${objectName}`);
+            }
+            utils_1.logger.info(`✅ DeleteObject completed successfully: ${objectName}`);
+            return (0, utils_1.return_response)({
+                data: JSON.stringify(response.data, null, 2)
+            });
+        }
+        catch (error) {
+            utils_1.logger.error(`Error deleting object ${objectName}:`, error);
+            // Parse error message for better user feedback
+            let errorMessage = `Failed to delete object: ${error.message || String(error)}`;
+            if (error.response?.status === 404) {
+                errorMessage = `Object ${objectName} not found. It may already be deleted.`;
+            }
+            else if (error.response?.status === 423) {
+                errorMessage = `Object ${objectName} is locked by another user. Cannot delete.`;
+            }
+            else if (error.response?.status === 400) {
+                errorMessage = `Bad request. Check if transport request is required and valid.`;
+            }
+            else if (error.response?.data && typeof error.response.data === 'string') {
+                // Try to parse XML error message
+                try {
+                    const parser = new fast_xml_parser_1.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, use default message
+                }
+            }
+            return (0, utils_1.return_error)(new Error(errorMessage));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}