@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/domain/handleUpdateDomain.d.ts

@@ -0,0 +1,99 @@
+/**
+ * UpdateDomain Handler - Update Existing ABAP Domain
+ *
+ * Uses DomainBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: lock -> update -> check -> unlock -> (activate)
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "UpdateDomain";
+    readonly description: "Update an existing ABAP domain in SAP system.\n\nWorkflow:\n1. Acquires lock on the domain\n2. Updates domain with provided parameters (complete replacement)\n3. Performs syntax check\n4. Unlocks domain\n5. Optionally activates domain (default: true)\n6. Returns updated domain details\n\nNote: All provided parameters completely replace existing values. Use GetDomain first to see current values if needed.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly domain_name: {
+                readonly type: "string";
+                readonly description: "Domain name to update (e.g., ZZ_TEST_0001)";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "New domain description (optional)";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name (e.g., ZOK_LOCAL, $TMP for local objects)";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number (e.g., E19K905635). Required for transportable packages.";
+            };
+            readonly datatype: {
+                readonly type: "string";
+                readonly description: "Data type: CHAR, NUMC, DATS, TIMS, DEC, INT1, INT2, INT4, INT8, CURR, QUAN, etc.";
+            };
+            readonly length: {
+                readonly type: "number";
+                readonly description: "Field length (max depends on datatype)";
+            };
+            readonly decimals: {
+                readonly type: "number";
+                readonly description: "Decimal places (for DEC, CURR, QUAN types)";
+            };
+            readonly conversion_exit: {
+                readonly type: "string";
+                readonly description: "Conversion exit routine name (without CONVERSION_EXIT_ prefix)";
+            };
+            readonly lowercase: {
+                readonly type: "boolean";
+                readonly description: "Allow lowercase input";
+            };
+            readonly sign_exists: {
+                readonly type: "boolean";
+                readonly description: "Field has sign (+/-)";
+            };
+            readonly value_table: {
+                readonly type: "string";
+                readonly description: "Value table name for foreign key relationship";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate domain after update (default: true)";
+                readonly default: true;
+            };
+            readonly fixed_values: {
+                readonly type: "array";
+                readonly description: "Array of fixed values for domain value range";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly low: {
+                            readonly type: "string";
+                            readonly description: "Fixed value (e.g., '001', 'A')";
+                        };
+                        readonly text: {
+                            readonly type: "string";
+                            readonly description: "Description text for the fixed value";
+                        };
+                    };
+                    readonly required: readonly ["low", "text"];
+                };
+            };
+        };
+        readonly required: readonly ["domain_name", "package_name"];
+    };
+};
+/**
+ * Main handler for UpdateDomain tool
+ *
+ * Uses DomainBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleUpdateDomain(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleUpdateDomain.d.ts.map

package/dist/handlers/domain/handleUpdateDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleUpdateDomain.d.ts","sourceRoot":"","sources":["../../../src/handlers/domain/handleUpdateDomain.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsFlB,CAAC;AAkBX;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;;;;;;GAqHjD"}

package/dist/handlers/domain/handleUpdateDomain.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * UpdateDomain Handler - Update Existing ABAP Domain
+ *
+ * Uses DomainBuilder 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.handleUpdateDomain = handleUpdateDomain;
+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: "UpdateDomain",
+    description: `Update an existing ABAP domain in SAP system.
+
+Workflow:
+1. Acquires lock on the domain
+2. Updates domain with provided parameters (complete replacement)
+3. Performs syntax check
+4. Unlocks domain
+5. Optionally activates domain (default: true)
+6. Returns updated domain details
+
+Note: All provided parameters completely replace existing values. Use GetDomain first to see current values if needed.`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            domain_name: {
+                type: "string",
+                description: "Domain name to update (e.g., ZZ_TEST_0001)"
+            },
+            description: {
+                type: "string",
+                description: "New domain description (optional)"
+            },
+            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."
+            },
+            datatype: {
+                type: "string",
+                description: "Data type: CHAR, NUMC, DATS, TIMS, DEC, INT1, INT2, INT4, INT8, CURR, QUAN, etc."
+            },
+            length: {
+                type: "number",
+                description: "Field length (max depends on datatype)"
+            },
+            decimals: {
+                type: "number",
+                description: "Decimal places (for DEC, CURR, QUAN types)"
+            },
+            conversion_exit: {
+                type: "string",
+                description: "Conversion exit routine name (without CONVERSION_EXIT_ prefix)"
+            },
+            lowercase: {
+                type: "boolean",
+                description: "Allow lowercase input"
+            },
+            sign_exists: {
+                type: "boolean",
+                description: "Field has sign (+/-)"
+            },
+            value_table: {
+                type: "string",
+                description: "Value table name for foreign key relationship"
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate domain after update (default: true)",
+                default: true
+            },
+            fixed_values: {
+                type: "array",
+                description: "Array of fixed values for domain value range",
+                items: {
+                    type: "object",
+                    properties: {
+                        low: {
+                            type: "string",
+                            description: "Fixed value (e.g., '001', 'A')"
+                        },
+                        text: {
+                            type: "string",
+                            description: "Description text for the fixed value"
+                        }
+                    },
+                    required: ["low", "text"]
+                }
+            }
+        },
+        required: ["domain_name", "package_name"]
+    }
+};
+/**
+ * Main handler for UpdateDomain tool
+ *
+ * Uses DomainBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleUpdateDomain(args) {
+    try {
+        if (!args?.domain_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Domain 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 domainName = typedArgs.domain_name.toUpperCase();
+        utils_2.logger.info(`Starting domain update: ${domainName}`);
+        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.validateDomain(domainName);
+            // Lock
+            await client.lockDomain(domainName);
+            const lockHandle = client.getLockHandle();
+            try {
+                // Update with properties
+                const properties = {
+                    datatype: typedArgs.datatype,
+                    length: typedArgs.length,
+                    decimals: typedArgs.decimals,
+                    conversion_exit: typedArgs.conversion_exit,
+                    lowercase: typedArgs.lowercase,
+                    sign_exists: typedArgs.sign_exists,
+                    value_table: typedArgs.value_table,
+                    fixed_values: typedArgs.fixed_values
+                };
+                await client.updateDomain(domainName, properties, lockHandle);
+                // Check
+                await client.checkDomain(domainName);
+                // Unlock
+                await client.unlockDomain(domainName, lockHandle);
+                // Activate if requested
+                if (shouldActivate) {
+                    await client.activateDomain(domainName);
+                }
+            }
+            catch (error) {
+                // Try to unlock on error
+                try {
+                    await client.unlockDomain(domainName, lockHandle);
+                }
+                catch (unlockError) {
+                    utils_2.logger.error('Failed to unlock domain after error:', unlockError);
+                }
+                throw error;
+            }
+            // Get domain details from update result
+            const updateResult = client.getUpdateResult();
+            let domainDetails = null;
+            if (updateResult?.data && typeof updateResult.data === 'object' && 'domain_details' in updateResult.data) {
+                domainDetails = updateResult.data.domain_details;
+            }
+            return (0, utils_2.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    domain_name: domainName,
+                    package: typedArgs.package_name,
+                    transport_request: typedArgs.transport_request,
+                    status: shouldActivate ? 'active' : 'inactive',
+                    message: `Domain ${domainName} updated${shouldActivate ? ' and activated' : ''} successfully`,
+                    domain_details: domainDetails
+                })
+            });
+        }
+        catch (error) {
+            utils_2.logger.error(`Error updating domain ${domainName}:`, error);
+            // Handle specific error cases
+            if (error.message?.includes('not found') || error.response?.status === 404) {
+                throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, `Domain ${domainName} not found.`);
+            }
+            if (error.message?.includes('locked') || error.response?.status === 403) {
+                throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Domain ${domainName} 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 domain ${domainName}: ${errorMessage}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}

package/dist/handlers/domain/readonly/handleGetDomain.d.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetDomain";
+    readonly description: "[read-only] Retrieve ABAP domain structure and properties from SAP system.";
+    readonly inputSchema: {
+        readonly domain_name: z.ZodString;
+    };
+};
+interface DomainArgs {
+    domain_name: string;
+}
+/**
+ * Main handler for GetDomain MCP tool
+ */
+export declare function handleGetDomain(args: DomainArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleGetDomain.d.ts.map

package/dist/handlers/domain/readonly/handleGetDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetDomain.d.ts","sourceRoot":"","sources":["../../../../src/handlers/domain/readonly/handleGetDomain.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAEX,UAAU,UAAU;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,UAAU;;;;;;GA6FrD"}

package/dist/handlers/domain/readonly/handleGetDomain.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetDomain = handleGetDomain;
+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: "GetDomain",
+    description: "[read-only] Retrieve ABAP domain structure and properties from SAP system.",
+    inputSchema: {
+        domain_name: z.string().describe("Domain name (e.g., MATNR, CHAR20, ZZ_TEST_DOMAIN)")
+    }
+};
+/**
+ * Main handler for GetDomain MCP tool
+ */
+async function handleGetDomain(args) {
+    try {
+        // Validate required parameters
+        if (!args?.domain_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Domain name is required');
+        }
+        const typedArgs = args;
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.CrudClient(connection);
+        await client.readDomain(typedArgs.domain_name);
+        const response = client.getReadResult();
+        if (!response) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to read domain');
+        }
+        // Parse XML response
+        const parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+        });
+        const result = parser.parse(response.data);
+        const domain = result['doma:domain'];
+        if (!domain) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to parse domain XML response');
+        }
+        // Extract domain information
+        const domainInfo = {
+            name: domain['adtcore:name'],
+            type: domain['adtcore:type'],
+            description: domain['adtcore:description'] || '',
+            language: domain['adtcore:language'],
+            masterLanguage: domain['adtcore:masterLanguage'],
+            masterSystem: domain['adtcore:masterSystem'],
+            responsible: domain['adtcore:responsible'],
+            createdBy: domain['adtcore:createdBy'],
+            createdAt: domain['adtcore:createdAt'],
+            changedBy: domain['adtcore:changedBy'],
+            changedAt: domain['adtcore:changedAt'],
+            version: domain['adtcore:version'],
+            abapLanguageVersion: domain['adtcore:abapLanguageVersion'],
+            package: {
+                name: domain['adtcore:packageRef']?.['adtcore:name'],
+                type: domain['adtcore:packageRef']?.['adtcore:type'],
+                description: domain['adtcore:packageRef']?.['adtcore:description'],
+                uri: domain['adtcore:packageRef']?.['adtcore:uri']
+            },
+            content: domain['doma:content'] ? {
+                typeInformation: {
+                    datatype: domain['doma:content']['doma:typeInformation']?.['doma:datatype'],
+                    length: domain['doma:content']['doma:typeInformation']?.['doma:length'],
+                    decimals: domain['doma:content']['doma:typeInformation']?.['doma:decimals']
+                },
+                outputInformation: {
+                    length: domain['doma:content']['doma:outputInformation']?.['doma:length'],
+                    style: domain['doma:content']['doma:outputInformation']?.['doma:style'],
+                    conversionExit: domain['doma:content']['doma:outputInformation']?.['doma:conversionExit'] || '',
+                    signExists: domain['doma:content']['doma:outputInformation']?.['doma:signExists'],
+                    lowercase: domain['doma:content']['doma:outputInformation']?.['doma:lowercase'],
+                    ampmFormat: domain['doma:content']['doma:outputInformation']?.['doma:ampmFormat']
+                },
+                valueInformation: {
+                    valueTableRef: domain['doma:content']['doma:valueInformation']?.['doma:valueTableRef'] || '',
+                    appendExists: domain['doma:content']['doma:valueInformation']?.['doma:appendExists'],
+                    fixValues: domain['doma:content']['doma:valueInformation']?.['doma:fixValues']
+                }
+            } : null
+        };
+        return (0, utils_2.return_response)({
+            data: JSON.stringify({
+                success: true,
+                domain: domainInfo,
+                raw_xml: response.data
+            }, null, 2),
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            config: response.config
+        });
+    }
+    catch (error) {
+        console.error('[GetDomain] Error:', error);
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}

package/dist/handlers/enhancement/handleGetEnhancementImpl.d.ts

@@ -0,0 +1,69 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetEnhancementImpl";
+    readonly description: "Retrieve source code of a specific enhancement implementation by its name and enhancement spot.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly enhancement_spot: {
+                readonly type: "string";
+                readonly description: "Name of the enhancement spot";
+            };
+            readonly enhancement_name: {
+                readonly type: "string";
+                readonly description: "Name of the enhancement implementation";
+            };
+        };
+        readonly required: readonly ["enhancement_spot", "enhancement_name"];
+    };
+};
+/**
+ * Interface for enhancement by name response
+ */
+export interface EnhancementByNameResponse {
+    enhancement_spot: string;
+    enhancement_name: string;
+    source_code: string;
+}
+/**
+ * Handler to retrieve a specific enhancement implementation by name in an ABAP system.
+ * This function is intended for retrieving the source code of a specific enhancement implementation (requires both spot and implementation name).
+ * This function uses the SAP ADT API endpoint to fetch the source code of a specific enhancement
+ * implementation within a given enhancement spot. If the implementation is not found, it falls back
+ * to retrieving metadata about the enhancement spot itself to provide context about the failure.
+ *
+ * @param args - Tool arguments containing:
+ *   - enhancement_spot: Name of the enhancement spot (e.g., 'enhoxhh'). This is a required parameter.
+ *   - enhancement_name: Name of the specific enhancement implementation (e.g., 'zpartner_update_pai'). This is a required parameter.
+ * @returns Response object containing:
+ *   - If successful: enhancement_spot, enhancement_name, source_code, and raw_xml of the enhancement implementation.
+ *   - If implementation not found: enhancement_spot, enhancement_name, status as 'not_found', a message, spot_metadata, and raw_xml of the spot.
+ *   - In case of error: an error object with details about the failure.
+ */
+export declare function handleGetEnhancementImpl(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        json: EnhancementByNameResponse;
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        json: {
+            enhancement_spot: any;
+            enhancement_name: any;
+            status: string;
+            message: string;
+            spot_metadata: {
+                description?: string;
+            };
+        };
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=handleGetEnhancementImpl.d.ts.map

package/dist/handlers/enhancement/handleGetEnhancementImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetEnhancementImpl.d.ts","sourceRoot":"","sources":["../../../src/handlers/enhancement/handleGetEnhancementImpl.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAoBlB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACvB;AA2CD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;;;;;8BA4DR,MAAM;;;;;;;;;;GA6CrD"}