@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/search/handleSearchObject.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleSearchObject = handleSearchObject;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const getObjectsListCache_1 = require("../../lib/getObjectsListCache");
+exports.TOOL_DEFINITION = {
+    name: "SearchObject",
+    description: "Search for ABAP objects by name pattern. Parameters: object_name (with or without mask), object_type (optional), maxResults (optional). If object_type is specified, results are filtered by type.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            object_name: { type: "string", description: "Object name or mask (e.g. 'MARA*')" },
+            object_type: { type: "string", description: "Optional ABAP object type (e.g. 'TABL', 'CLAS/OC')" },
+            maxResults: { type: "number", description: "Maximum number of results to return", default: 100 }
+        },
+        required: ["object_name"]
+    }
+};
+// --- New function for ADT error handling ---
+function detectAdtSearchError(response) {
+    if (!response)
+        return null;
+    const status = response.status || response?.response?.status;
+    if (status !== 200) {
+        let msg = `ADT request failed (status ${status})`;
+        if (status === 406)
+            msg = "Invalid object_type (406 Not Acceptable)";
+        if (status === 400)
+            msg = "Bad request (400)";
+        return {
+            isError: true,
+            content: [{ type: "text", text: msg }]
+        };
+    }
+    return null;
+}
+async function handleSearchObject(args) {
+    try {
+        const { object_name, object_type, maxResults } = args;
+        if (!object_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'object_name is required');
+        }
+        const query = object_name;
+        let url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/repository/informationsystem/search?operation=quickSearch&query=${(0, utils_2.encodeSapObjectName)(query)}&maxResults=${maxResults || 100}`;
+        // Append object_type as a filter when provided
+        if (object_type) {
+            url += `&objectType=${(0, utils_2.encodeSapObjectName)(object_type)}`;
+        }
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default');
+        // --- Error handling using new function ---
+        const adtError = detectAdtSearchError(response);
+        if (adtError)
+            return adtError;
+        let result = (0, utils_2.return_response)(response);
+        const { isError, ...rest } = result;
+        // Detect empty XML (<adtcore:objectReferences/>) results
+        const xmlText = rest.content?.[0]?.text || "";
+        if (!xmlText.includes("<adtcore:objectReference ")) {
+            // Return an empty result (not an error) when ADT finds nothing
+            return {
+                isError: false,
+                content: []
+            };
+        }
+        // Parse every <adtcore:objectReference .../> entry from the XML
+        const matches = Array.from(xmlText.matchAll(/<adtcore:objectReference\s+([^>]*)\/>/g));
+        if (!matches || matches.length === 0) {
+            // Return an empty result (not an error) when ADT finds nothing
+            return {
+                isError: false,
+                content: []
+            };
+        }
+        const resultsArr = [];
+        for (const m of matches) {
+            const attrs = m[1];
+            function extract(attr, def = "") {
+                const mm = attrs.match(new RegExp(attr + '="([^"]*)"'));
+                return mm ? mm[1] : def;
+            }
+            const name = extract("adtcore:name");
+            const type = extract("adtcore:type");
+            const description = extract("adtcore:description");
+            let pkgName = extract("adtcore:packageName");
+            // If packageName is missing, attempt to pull it from the raw XML via <adtcore:packageName>
+            if (!pkgName) {
+                const pkgMatch = xmlText.match(/<adtcore:packageName>([^<]*)<\/adtcore:packageName>/);
+                if (pkgMatch) {
+                    pkgName = pkgMatch[1];
+                }
+            }
+            resultsArr.push({ name, type, description, packageName: pkgName });
+        }
+        getObjectsListCache_1.objectsListCache.setCache(result);
+        return {
+            isError: false,
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ results: resultsArr, rawXML: xmlText })
+                }
+            ]
+        };
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+}

package/dist/handlers/service_definition/readonly/handleGetServiceDefinition.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetServiceDefinition";
+    readonly description: "[read-only] Retrieve ABAP CDS Service Definition metadata and source code.";
+    readonly inputSchema: {
+        readonly service_definition_name: z.ZodString;
+    };
+};
+export declare function handleGetServiceDefinition(args: any): Promise<{
+    isError: boolean;
+    content: Array<{
+        type: string;
+        text?: string;
+        json?: any;
+    }>;
+}>;
+//# sourceMappingURL=handleGetServiceDefinition.d.ts.map

package/dist/handlers/service_definition/readonly/handleGetServiceDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetServiceDefinition.d.ts","sourceRoot":"","sources":["../../../../src/handlers/service_definition/readonly/handleGetServiceDefinition.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAsCX,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAsDtJ"}

package/dist/handlers/service_definition/readonly/handleGetServiceDefinition.js

@@ -0,0 +1,136 @@
+"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.handleGetServiceDefinition = handleGetServiceDefinition;
+const utils_1 = require("../../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const writeResultToFile_1 = require("../../../lib/writeResultToFile");
+const z = __importStar(require("zod"));
+exports.TOOL_DEFINITION = {
+    name: "GetServiceDefinition",
+    description: "[read-only] Retrieve ABAP CDS Service Definition metadata and source code.",
+    inputSchema: {
+        service_definition_name: z.string().describe("Name of the ABAP CDS Service Definition")
+    }
+};
+function parseServiceDefinitionXml(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        parseAttributeValue: true,
+        trimValues: true
+    });
+    const result = parser.parse(xml);
+    // ADT Service Definition XML (SRVD/SRVD)
+    if (result['srvd:srvdSource'] || result['srvdSource']) {
+        const srvd = result['srvd:srvdSource'] || result['srvdSource'];
+        const packageRef = srvd['adtcore:packageRef'] || srvd['packageRef'];
+        return {
+            name: srvd['adtcore:name'] || srvd['name'],
+            objectType: 'service_definition',
+            description: srvd['adtcore:description'] || srvd['description'] || '',
+            package: packageRef?.['adtcore:name'] || packageRef?.['name'] || null,
+            uri: srvd['adtcore:uri'] || srvd['uri'] || null,
+            version: srvd['adtcore:version'] || srvd['version'] || null,
+            language: srvd['adtcore:language'] || srvd['language'] || null,
+            masterLanguage: srvd['adtcore:masterLanguage'] || srvd['masterLanguage'] || null,
+            masterSystem: srvd['adtcore:masterSystem'] || srvd['masterSystem'] || null,
+            responsible: srvd['adtcore:responsible'] || srvd['responsible'] || null,
+            createdBy: srvd['adtcore:createdBy'] || srvd['createdBy'] || null,
+            createdAt: srvd['adtcore:createdAt'] || srvd['createdAt'] || null,
+            changedBy: srvd['adtcore:changedBy'] || srvd['changedBy'] || null,
+            changedAt: srvd['adtcore:changedAt'] || srvd['changedAt'] || null
+        };
+    }
+    // fallback: return raw
+    return { raw: result };
+}
+async function handleGetServiceDefinition(args) {
+    try {
+        if (!args?.service_definition_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Service definition name is required');
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.ReadOnlyClient(connection);
+        await client.readServiceDefinition(args.service_definition_name);
+        const config = client.getServiceDefinitionReadResult();
+        const response = client.getReadResult();
+        if (!response) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to read service definition');
+        }
+        // Parse XML responses; otherwise return the payload unchanged
+        if (typeof response.data === 'string' && response.data.trim().startsWith('<?xml')) {
+            const parsed = parseServiceDefinitionXml(response.data);
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "json",
+                        json: {
+                            ...parsed,
+                            config: config || null,
+                            raw_xml: response.data
+                        }
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(result, args.filePath);
+            }
+            return result;
+        }
+        else {
+            const plainResult = (0, utils_1.return_response)(response);
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(plainResult, args.filePath);
+            }
+            return plainResult;
+        }
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+}

package/dist/handlers/structure/handleCreateStructure.d.ts

@@ -0,0 +1,107 @@
+/**
+ * CreateStructure Handler - ABAP Structure Creation via ADT API
+ *
+ * Uses StructureBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> create -> lock -> update -> check -> unlock -> (activate)
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateStructure";
+    readonly description: "Create a new ABAP structure in SAP system with fields and type references. Includes create, activate, and verify steps.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly structure_name: {
+                readonly type: "string";
+                readonly description: "Structure name (e.g., ZZ_S_TEST_001). Must follow SAP naming conventions.";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Structure description. If not provided, structure_name will be used.";
+            };
+            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 fields: {
+                readonly type: "array";
+                readonly description: "Array of structure fields";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "Field name (e.g., CLIENT, MATERIAL_ID)";
+                        };
+                        readonly data_type: {
+                            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";
+                        };
+                        readonly decimals: {
+                            readonly type: "number";
+                            readonly description: "Decimal places (for DEC, CURR, QUAN types)";
+                            readonly default: 0;
+                        };
+                        readonly domain: {
+                            readonly type: "string";
+                            readonly description: "Domain name for type reference (optional)";
+                        };
+                        readonly data_element: {
+                            readonly type: "string";
+                            readonly description: "Data element name for type reference (optional)";
+                        };
+                        readonly structure_ref: {
+                            readonly type: "string";
+                            readonly description: "Include another structure (optional)";
+                        };
+                        readonly table_ref: {
+                            readonly type: "string";
+                            readonly description: "Reference to table type (optional)";
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                            readonly description: "Field description";
+                        };
+                    };
+                    readonly required: readonly ["name"];
+                };
+            };
+            readonly includes: {
+                readonly type: "array";
+                readonly description: "Include other structures in this structure";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "Include structure name";
+                        };
+                        readonly suffix: {
+                            readonly type: "string";
+                            readonly description: "Optional suffix for include fields";
+                        };
+                    };
+                    readonly required: readonly ["name"];
+                };
+            };
+        };
+        readonly required: readonly ["structure_name", "package_name", "fields"];
+    };
+};
+/**
+ * Main handler for CreateStructure MCP tool
+ *
+ * Uses StructureBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleCreateStructure(args: any): Promise<any>;
+//# sourceMappingURL=handleCreateStructure.d.ts.map

package/dist/handlers/structure/handleCreateStructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateStructure.d.ts","sourceRoot":"","sources":["../../../src/handlers/structure/handleCreateStructure.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0FlB,CAAC;AA6BX;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAmGnE"}

package/dist/handlers/structure/handleCreateStructure.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * CreateStructure Handler - ABAP Structure Creation via ADT API
+ *
+ * Uses StructureBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> create -> lock -> update -> check -> unlock -> (activate)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCreateStructure = handleCreateStructure;
+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: "CreateStructure",
+    description: "Create a new ABAP structure in SAP system with fields and type references. Includes create, activate, and verify steps.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            structure_name: {
+                type: "string",
+                description: "Structure name (e.g., ZZ_S_TEST_001). Must follow SAP naming conventions."
+            },
+            description: {
+                type: "string",
+                description: "Structure description. If not provided, structure_name will be used."
+            },
+            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."
+            },
+            fields: {
+                type: "array",
+                description: "Array of structure fields",
+                items: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Field name (e.g., CLIENT, MATERIAL_ID)"
+                        },
+                        data_type: {
+                            type: "string",
+                            description: "Data type: CHAR, NUMC, DATS, TIMS, DEC, INT1, INT2, INT4, INT8, CURR, QUAN, etc."
+                        },
+                        length: {
+                            type: "number",
+                            description: "Field length"
+                        },
+                        decimals: {
+                            type: "number",
+                            description: "Decimal places (for DEC, CURR, QUAN types)",
+                            default: 0
+                        },
+                        domain: {
+                            type: "string",
+                            description: "Domain name for type reference (optional)"
+                        },
+                        data_element: {
+                            type: "string",
+                            description: "Data element name for type reference (optional)"
+                        },
+                        structure_ref: {
+                            type: "string",
+                            description: "Include another structure (optional)"
+                        },
+                        table_ref: {
+                            type: "string",
+                            description: "Reference to table type (optional)"
+                        },
+                        description: {
+                            type: "string",
+                            description: "Field description"
+                        }
+                    },
+                    required: ["name"]
+                }
+            },
+            includes: {
+                type: "array",
+                description: "Include other structures in this structure",
+                items: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Include structure name"
+                        },
+                        suffix: {
+                            type: "string",
+                            description: "Optional suffix for include fields"
+                        }
+                    },
+                    required: ["name"]
+                }
+            }
+        },
+        required: ["structure_name", "package_name", "fields"]
+    }
+};
+/**
+ * Main handler for CreateStructure MCP tool
+ *
+ * Uses StructureBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleCreateStructure(args) {
+    try {
+        const createStructureArgs = args;
+        // Validate required parameters
+        if (!createStructureArgs?.structure_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Structure name is required');
+        }
+        if (!createStructureArgs?.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)(createStructureArgs.package_name, createStructureArgs.transport_request);
+        if (!createStructureArgs?.fields || !Array.isArray(createStructureArgs.fields) || createStructureArgs.fields.length === 0) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'At least one field is required');
+        }
+        const connection = (0, utils_2.getManagedConnection)();
+        const structureName = createStructureArgs.structure_name.toUpperCase();
+        utils_2.logger.info(`Starting structure creation: ${structureName}`);
+        try {
+            // Create client
+            const client = new adt_clients_1.CrudClient(connection);
+            const shouldActivate = true; // Default to true for structures
+            // Validate
+            await client.validateStructure(structureName);
+            // Create
+            await client.createStructure(structureName, createStructureArgs.description || structureName, createStructureArgs.package_name, createStructureArgs.transport_request);
+            // Lock
+            await client.lockStructure(structureName);
+            const lockHandle = client.getLockHandle();
+            // Note: StructureBuilder internally generates DDL from fields/includes
+            // For now, skip update as structure creation already includes field definitions
+            // TODO: Implement DDL generation or enhance CrudClient to accept fields directly
+            // Check
+            await client.checkStructure(structureName);
+            // Unlock
+            await client.unlockStructure(structureName, lockHandle);
+            // Activate
+            if (shouldActivate) {
+                await client.activateStructure(structureName);
+            }
+            utils_2.logger.info(`✅ CreateStructure completed successfully: ${structureName}`);
+            return (0, utils_2.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    structure_name: structureName,
+                    package_name: createStructureArgs.package_name,
+                    transport_request: createStructureArgs.transport_request || 'local',
+                    activated: shouldActivate,
+                    message: `Structure ${structureName} created successfully${shouldActivate ? ' and activated' : ''}`
+                })
+            });
+        }
+        catch (error) {
+            utils_2.logger.error(`Error creating structure ${structureName}:`, error);
+            // Check if structure already exists
+            if (error.message?.includes('already exists') || error.response?.status === 409) {
+                throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, `Structure ${structureName} already exists. Please delete it first or use a different name.`);
+            }
+            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 create structure ${structureName}: ${errorMessage}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}

package/dist/handlers/structure/handleGetStructure.d.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetStructure";
+    readonly description: "Retrieve ABAP Structure.";
+    readonly inputSchema: {
+        readonly structure_name: z.ZodString;
+    };
+};
+export declare function handleGetStructure(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleGetStructure.d.ts.map

package/dist/handlers/structure/handleGetStructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetStructure.d.ts","sourceRoot":"","sources":["../../../src/handlers/structure/handleGetStructure.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAsCX,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;;;;;;GAsDjD"}