@mcp-abap-adt/core 2.5.0 → 2.5.2

package/dist/handlers/data_element/handleUpdateDataElement.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * UpdateDataElement Handler - Update Existing ABAP Data Element
+ *
+ * Uses DataElementBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: lock -> update -> check -> unlock -> (activate)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleUpdateDataElement = handleUpdateDataElement;
+const utils_1 = require("../../lib/utils");
+const utils_2 = 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: "UpdateDataElement",
+    description: `Update an existing ABAP data element in SAP system.
+
+Workflow:
+1. Gets domain info (if type_kind is 'domain') to extract dataType/length/decimals
+2. Acquires lock on the data element
+3. Updates data element with provided parameters (complete replacement)
+4. Unlocks data element
+5. Optionally activates data element (default: true)
+6. Returns updated data element details
+
+Supported type_kind values:
+- domain: Based on ABAP domain (requires type_name = domain name)
+- predefinedAbapType: Direct ABAP type (requires data_type, length, decimals)
+- refToPredefinedAbapType: Reference to ABAP type (requires data_type, length, decimals)
+- refToDictionaryType: Reference to another data element (requires type_name = data element name)
+- refToClifType: Reference to class (requires type_name = class name)
+
+Note: All provided parameters completely replace existing values. Field labels are truncated to max lengths (10/20/40/55).`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            data_element_name: {
+                type: "string",
+                description: "Data element name to update (e.g., ZZ_TEST_DTEL_01)"
+            },
+            description: {
+                type: "string",
+                description: "New data element description"
+            },
+            package_name: {
+                type: "string",
+                description: "Package name (e.g., ZOK_LOCAL, $TMP for local objects)"
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number (e.g., E19K905635). Required for transportable packages."
+            },
+            type_kind: {
+                type: "string",
+                description: "Type kind: domain, predefinedAbapType, refToPredefinedAbapType, refToDictionaryType, refToClifType",
+                enum: ["domain", "predefinedAbapType", "refToPredefinedAbapType", "refToDictionaryType", "refToClifType"],
+                default: "domain"
+            },
+            type_name: {
+                type: "string",
+                description: "Type name: domain name, data element name, or class name (depending on type_kind)"
+            },
+            data_type: {
+                type: "string",
+                description: "Data type (CHAR, NUMC, etc.) - for predefinedAbapType or refToPredefinedAbapType"
+            },
+            length: {
+                type: "number",
+                description: "Length - for predefinedAbapType or refToPredefinedAbapType"
+            },
+            decimals: {
+                type: "number",
+                description: "Decimals - for predefinedAbapType or refToPredefinedAbapType"
+            },
+            domain_name: {
+                type: "string",
+                description: "Domain name (deprecated - use type_name with type_kind=domain)"
+            },
+            field_label_short: {
+                type: "string",
+                description: "Short field label (max 10 chars)"
+            },
+            field_label_medium: {
+                type: "string",
+                description: "Medium field label (max 20 chars)"
+            },
+            field_label_long: {
+                type: "string",
+                description: "Long field label (max 40 chars)"
+            },
+            field_label_heading: {
+                type: "string",
+                description: "Heading field label (max 55 chars)"
+            },
+            search_help: {
+                type: "string",
+                description: "Search help name"
+            },
+            search_help_parameter: {
+                type: "string",
+                description: "Search help parameter"
+            },
+            set_get_parameter: {
+                type: "string",
+                description: "Set/Get parameter ID"
+            },
+            default_component_name: {
+                type: "string",
+                description: "Default component name"
+            },
+            deactivate_input_history: {
+                type: "boolean",
+                description: "Deactivate input history",
+                default: false
+            },
+            change_document: {
+                type: "boolean",
+                description: "Change document",
+                default: false
+            },
+            left_to_right_direction: {
+                type: "boolean",
+                description: "Left to right direction",
+                default: false
+            },
+            deactivate_bidi_filtering: {
+                type: "boolean",
+                description: "Deactivate BiDi filtering",
+                default: false
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate data element after update (default: true)",
+                default: true
+            }
+        },
+        required: ["data_element_name", "package_name"]
+    }
+};
+/**
+ * Main handler for UpdateDataElement tool
+ *
+ * Uses DataElementBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleUpdateDataElement(args) {
+    try {
+        if (!args?.data_element_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Data element name is required');
+        }
+        if (!args?.package_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Package name is required');
+        }
+        // Validate transport_request: required for non-$TMP packages
+        (0, transportValidation_js_1.validateTransportRequest)(args.package_name, args.transport_request);
+        const typedArgs = args;
+        const connection = (0, utils_2.getManagedConnection)();
+        const dataElementName = typedArgs.data_element_name.toUpperCase();
+        utils_2.logger.info(`Starting data element update: ${dataElementName}`);
+        try {
+            // Determine domain name for builder (support deprecated domain_name parameter)
+            const domainName = typedArgs.type_name || typedArgs.domain_name;
+            const rawTypeKind = (typedArgs.type_kind || 'domain').toString().toLowerCase();
+            const typeKindMap = {
+                domain: 'domain',
+                builtin: 'predefinedAbapType',
+                predefinedabaptype: 'predefinedAbapType',
+                reftopredefinedabaptype: 'refToPredefinedAbapType',
+                reftodictionarytype: 'refToDictionaryType',
+                reftocliftype: 'refToClifType'
+            };
+            const typeKind = typeKindMap[rawTypeKind] || 'domain';
+            // Create client
+            const client = new adt_clients_1.CrudClient(connection);
+            const shouldActivate = typedArgs.activate !== false; // Default to true if not specified
+            // Validate
+            await client.validateDataElement(dataElementName);
+            // Lock
+            await client.lockDataElement(dataElementName);
+            const lockHandle = client.getLockHandle();
+            try {
+                // Update with properties
+                const properties = {
+                    domainName: domainName?.toUpperCase() || '',
+                    dataType: typedArgs.data_type,
+                    length: typedArgs.length,
+                    decimals: typedArgs.decimals,
+                    shortLabel: typedArgs.field_label_short,
+                    mediumLabel: typedArgs.field_label_medium,
+                    longLabel: typedArgs.field_label_long,
+                    headingLabel: typedArgs.field_label_heading,
+                    typeKind: typeKind,
+                    typeName: typedArgs.type_name?.toUpperCase()
+                };
+                await client.updateDataElement(dataElementName, properties, lockHandle);
+                // Check
+                await client.checkDataElement(dataElementName);
+                // Unlock
+                await client.unlockDataElement(dataElementName, lockHandle);
+                // Activate if requested
+                if (shouldActivate) {
+                    await client.activateDataElement(dataElementName);
+                }
+            }
+            catch (error) {
+                // Try to unlock on error
+                try {
+                    await client.unlockDataElement(dataElementName, lockHandle);
+                }
+                catch (unlockError) {
+                    utils_2.logger.error('Failed to unlock data element after error:', unlockError);
+                }
+                throw error;
+            }
+            // Get data element details from update result
+            const updateResult = client.getUpdateResult();
+            let dataElementDetails = null;
+            if (updateResult?.data && typeof updateResult.data === 'object' && 'data_element_details' in updateResult.data) {
+                dataElementDetails = updateResult.data.data_element_details;
+            }
+            return (0, utils_2.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    data_element_name: dataElementName,
+                    package: typedArgs.package_name,
+                    transport_request: typedArgs.transport_request,
+                    domain_name: domainName?.toUpperCase(),
+                    status: shouldActivate ? 'active' : 'inactive',
+                    message: `Data element ${dataElementName} updated${shouldActivate ? ' and activated' : ''} successfully`,
+                    data_element_details: dataElementDetails
+                })
+            });
+        }
+        catch (error) {
+            utils_2.logger.error(`Error updating data element ${dataElementName}:`, error);
+            // Handle specific error cases
+            if (error.message?.includes('not found') || error.response?.status === 404) {
+                throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, `Data element ${dataElementName} not found.`);
+            }
+            if (error.message?.includes('locked') || error.response?.status === 403) {
+                throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Data element ${dataElementName} is locked by another user or session. Please try again later.`);
+            }
+            const errorMessage = error.response?.data
+                ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+                : error.message || String(error);
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to update data element ${dataElementName}: ${errorMessage}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}

package/dist/handlers/data_element/readonly/handleGetDataElement.d.ts

@@ -0,0 +1,33 @@
+/**
+ * GetDataElement Handler - Retrieve ABAP Data Element information via ADT API
+ *
+ * Retrieves complete data element metadata including:
+ * - Type definition (domain reference or built-in type)
+ * - Field labels (short, medium, long, heading)
+ * - Data type characteristics (type, length, decimals)
+ * - Search help and parameter information
+ * - Package and system information
+ */
+import * as z from 'zod';
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetDataElement";
+    readonly description: "[read-only] Retrieve ABAP data element information including type definition, field labels, and metadata from SAP system via ADT API.";
+    readonly inputSchema: {
+        readonly data_element_name: z.ZodString;
+    };
+};
+interface DataElementArgs {
+    data_element_name: string;
+}
+/**
+ * Main handler for GetDataElement MCP tool
+ */
+export declare function handleGetDataElement(args: DataElementArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleGetDataElement.d.ts.map

package/dist/handlers/data_element/readonly/handleGetDataElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetDataElement.d.ts","sourceRoot":"","sources":["../../../../src/handlers/data_element/readonly/handleGetDataElement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAEX,UAAU,eAAe;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AA0FD;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,eAAe;;;;;;GAqC/D"}

package/dist/handlers/data_element/readonly/handleGetDataElement.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * GetDataElement Handler - Retrieve ABAP Data Element information via ADT API
+ *
+ * Retrieves complete data element metadata including:
+ * - Type definition (domain reference or built-in type)
+ * - Field labels (short, medium, long, heading)
+ * - Data type characteristics (type, length, decimals)
+ * - Search help and parameter information
+ * - Package and system information
+ */
+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.handleGetDataElement = handleGetDataElement;
+const utils_1 = require("../../../lib/utils");
+const utils_2 = require("../../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const z = __importStar(require("zod"));
+exports.TOOL_DEFINITION = {
+    name: "GetDataElement",
+    description: "[read-only] Retrieve ABAP data element information including type definition, field labels, and metadata from SAP system via ADT API.",
+    inputSchema: {
+        data_element_name: z.string().describe("Data element name (e.g., MAKTX, MATNR, ZZ_E_TEST_001)")
+    }
+};
+/**
+ * Parse data element XML response to structured JSON
+ */
+function parseDataElementXml(xmlData) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        textNodeName: '_text',
+        parseAttributeValue: true,
+    });
+    const result = parser.parse(xmlData);
+    const wbobj = result['blue:wbobj'] || result['wbobj'];
+    if (!wbobj) {
+        throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Invalid data element XML structure');
+    }
+    // Extract core attributes
+    const coreAttrs = {
+        name: wbobj['adtcore:name'] || wbobj['name'],
+        type: wbobj['adtcore:type'] || wbobj['type'],
+        description: wbobj['adtcore:description'] || wbobj['description'],
+        language: wbobj['adtcore:language'] || wbobj['language'],
+        masterLanguage: wbobj['adtcore:masterLanguage'] || wbobj['masterLanguage'],
+        masterSystem: wbobj['adtcore:masterSystem'] || wbobj['masterSystem'],
+        responsible: wbobj['adtcore:responsible'] || wbobj['responsible'],
+        createdAt: wbobj['adtcore:createdAt'] || wbobj['createdAt'],
+        createdBy: wbobj['adtcore:createdBy'] || wbobj['createdBy'],
+        changedAt: wbobj['adtcore:changedAt'] || wbobj['changedAt'],
+        changedBy: wbobj['adtcore:changedBy'] || wbobj['changedBy'],
+        version: wbobj['adtcore:version'] || wbobj['version'],
+        abapLanguageVersion: wbobj['adtcore:abapLanguageVersion'] || wbobj['abapLanguageVersion']
+    };
+    // Extract package reference
+    const packageRef = wbobj['adtcore:packageRef'] || wbobj['packageRef'];
+    const packageInfo = packageRef ? {
+        name: packageRef['adtcore:name'] || packageRef['name'],
+        type: packageRef['adtcore:type'] || packageRef['type'],
+        description: packageRef['adtcore:description'] || packageRef['description'],
+        uri: packageRef['adtcore:uri'] || packageRef['uri']
+    } : null;
+    // Extract data element details
+    const dtel = wbobj['dtel:dataElement'] || wbobj['dataElement'];
+    const dataElementInfo = dtel ? {
+        typeKind: dtel['dtel:typeKind'] || dtel['typeKind'],
+        typeName: dtel['dtel:typeName'] || dtel['typeName'],
+        dataType: dtel['dtel:dataType'] || dtel['dataType'],
+        dataTypeLength: dtel['dtel:dataTypeLength'] || dtel['dataTypeLength'],
+        dataTypeDecimals: dtel['dtel:dataTypeDecimals'] || dtel['dataTypeDecimals'],
+        // Field labels
+        shortFieldLabel: dtel['dtel:shortFieldLabel'] || dtel['shortFieldLabel'],
+        shortFieldLength: dtel['dtel:shortFieldLength'] || dtel['shortFieldLength'],
+        shortFieldMaxLength: dtel['dtel:shortFieldMaxLength'] || dtel['shortFieldMaxLength'],
+        mediumFieldLabel: dtel['dtel:mediumFieldLabel'] || dtel['mediumFieldLabel'],
+        mediumFieldLength: dtel['dtel:mediumFieldLength'] || dtel['mediumFieldLength'],
+        mediumFieldMaxLength: dtel['dtel:mediumFieldMaxLength'] || dtel['mediumFieldMaxLength'],
+        longFieldLabel: dtel['dtel:longFieldLabel'] || dtel['longFieldLabel'],
+        longFieldLength: dtel['dtel:longFieldLength'] || dtel['longFieldLength'],
+        longFieldMaxLength: dtel['dtel:longFieldMaxLength'] || dtel['longFieldMaxLength'],
+        headingFieldLabel: dtel['dtel:headingFieldLabel'] || dtel['headingFieldLabel'],
+        headingFieldLength: dtel['dtel:headingFieldLength'] || dtel['headingFieldLength'],
+        headingFieldMaxLength: dtel['dtel:headingFieldMaxLength'] || dtel['headingFieldMaxLength'],
+        // Additional properties
+        searchHelp: dtel['dtel:searchHelp'] || dtel['searchHelp'],
+        searchHelpParameter: dtel['dtel:searchHelpParameter'] || dtel['searchHelpParameter'],
+        setGetParameter: dtel['dtel:setGetParameter'] || dtel['setGetParameter'],
+        defaultComponentName: dtel['dtel:defaultComponentName'] || dtel['defaultComponentName'],
+        deactivateInputHistory: dtel['dtel:deactivateInputHistory'] || dtel['deactivateInputHistory'],
+        changeDocument: dtel['dtel:changeDocument'] || dtel['changeDocument'],
+        leftToRightDirection: dtel['dtel:leftToRightDirection'] || dtel['leftToRightDirection'],
+        deactivateBIDIFiltering: dtel['dtel:deactivateBIDIFiltering'] || dtel['deactivateBIDIFiltering']
+    } : null;
+    return {
+        metadata: coreAttrs,
+        package: packageInfo,
+        dataElement: dataElementInfo
+    };
+}
+/**
+ * Main handler for GetDataElement MCP tool
+ */
+async function handleGetDataElement(args) {
+    try {
+        // Validate required parameters
+        if (!args?.data_element_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Data element name is required');
+        }
+        const typedArgs = args;
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.CrudClient(connection);
+        await client.readDataElement(typedArgs.data_element_name);
+        const response = client.getReadResult();
+        if (!response) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to read data element');
+        }
+        // Parse XML to JSON
+        const parsedData = parseDataElementXml(response.data);
+        return (0, utils_2.return_response)({
+            data: JSON.stringify({
+                success: true,
+                data_element: parsedData,
+                raw_xml: response.data
+            }, null, 2),
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            config: response.config
+        });
+    }
+    catch (error) {
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}

package/dist/handlers/ddlx/handleCreateMetadataExtension.d.ts

@@ -0,0 +1,41 @@
+/**
+ * CreateMetadataExtension Handler - ABAP Metadata Extension Creation via ADT API
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateMetadataExtension";
+    readonly description: "Create a new ABAP Metadata Extension (DDLX) in SAP system.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Metadata Extension name";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Description";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate after creation. Default: true";
+            };
+        };
+        readonly required: readonly ["name", "package_name"];
+    };
+};
+export declare function handleCreateMetadataExtension(params: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCreateMetadataExtension.d.ts.map

package/dist/handlers/ddlx/handleCreateMetadataExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateMetadataExtension.d.ts","sourceRoot":"","sources":["../../../src/handlers/ddlx/handleCreateMetadataExtension.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlB,CAAC;AAUX,wBAAsB,6BAA6B,CAAC,MAAM,EAAE,GAAG;;;;;;GAmE9D"}

package/dist/handlers/ddlx/handleCreateMetadataExtension.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * CreateMetadataExtension Handler - ABAP Metadata Extension Creation via ADT API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCreateMetadataExtension = handleCreateMetadataExtension;
+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: "CreateMetadataExtension",
+    description: "Create a new ABAP Metadata Extension (DDLX) in SAP system.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Metadata Extension name"
+            },
+            description: {
+                type: "string",
+                description: "Description"
+            },
+            package_name: {
+                type: "string",
+                description: "Package name"
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number"
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate after creation. Default: true"
+            }
+        },
+        required: ["name", "package_name"]
+    }
+};
+async function handleCreateMetadataExtension(params) {
+    const args = params;
+    if (!args.name || !args.package_name) {
+        return (0, utils_1.return_error)(new Error("Missing required parameters"));
+    }
+    try {
+        (0, transportValidation_js_1.validateTransportRequest)(args.package_name, args.transport_request);
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+    const name = args.name.toUpperCase();
+    const connection = (0, utils_1.getManagedConnection)();
+    utils_1.logger.info(`Starting DDLX creation: ${name}`);
+    try {
+        const client = new adt_clients_1.CrudClient(connection);
+        const shouldActivate = args.activate !== false;
+        // Create
+        await client.createMetadataExtension(name, args.description || name, args.package_name, args.transport_request || '');
+        // Lock
+        await client.lockMetadataExtension(name);
+        const lockHandle = client.getLockHandle();
+        // Check
+        await client.checkMetadataExtension(name);
+        // Unlock
+        await client.unlockMetadataExtension(name, lockHandle);
+        // Activate if requested
+        if (shouldActivate) {
+            await client.activateMetadataExtension(name);
+        }
+        const result = {
+            success: true,
+            name: name,
+            package_name: args.package_name,
+            type: 'DDLX',
+            message: shouldActivate
+                ? `Metadata Extension ${name} created and activated successfully`
+                : `Metadata Extension ${name} created successfully`
+        };
+        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 creating DDLX ${name}:`, error);
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/ddlx/handleUpdateMetadataExtension.d.ts

@@ -0,0 +1,37 @@
+/**
+ * UpdateMetadataExtension Handler - ABAP Metadata Extension Update via ADT API
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "UpdateMetadataExtension";
+    readonly description: "Update source code of an ABAP Metadata Extension.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Metadata Extension name";
+            };
+            readonly source_code: {
+                readonly type: "string";
+                readonly description: "New source code";
+            };
+            readonly lock_handle: {
+                readonly type: "string";
+                readonly description: "Lock handle from LockObject. If not provided, will attempt to lock internally.";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate after update. Default: true";
+            };
+        };
+        readonly required: readonly ["name", "source_code"];
+    };
+};
+export declare function handleUpdateMetadataExtension(params: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleUpdateMetadataExtension.d.ts.map

package/dist/handlers/ddlx/handleUpdateMetadataExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleUpdateMetadataExtension.d.ts","sourceRoot":"","sources":["../../../src/handlers/ddlx/handleUpdateMetadataExtension.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAC;AASX,wBAAsB,6BAA6B,CAAC,MAAM,EAAE,GAAG;;;;;;GAsD9D"}