@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/view/handleCreateView.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * CreateView Handler - CDS/Classic View Creation via ADT API
+ *
+ * Uses ViewBuilder 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.handleCreateView = handleCreateView;
+const utils_1 = require("../../lib/utils");
+const transportValidation_js_1 = require("../../utils/transportValidation.js");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "CreateView",
+    description: "Create CDS View or Classic View in SAP using DDL syntax. Both types use the same API workflow, differing only in DDL content (CDS has @AbapCatalog annotations).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            view_name: {
+                type: "string",
+                description: "View name (e.g., ZOK_R_TEST_0002, Z_I_MY_VIEW). Must follow SAP naming conventions."
+            },
+            ddl_source: {
+                type: "string",
+                description: "Complete DDL source code. CDS: include @AbapCatalog.sqlViewName and other annotations. Classic: plain 'define view' statement."
+            },
+            package_name: {
+                type: "string",
+                description: "Package name (e.g., ZOK_LAB, $TMP for local objects)"
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number (e.g., E19K905635). Required for transportable packages."
+            },
+            description: {
+                type: "string",
+                description: "Optional description. If not provided, view_name will be used."
+            }
+        },
+        required: ["view_name", "ddl_source", "package_name"]
+    }
+};
+/**
+ * Main handler for CreateView MCP tool
+ *
+ * Uses ViewBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleCreateView(params) {
+    try {
+        const args = params;
+        if (!args.view_name || !args.ddl_source || !args.package_name) {
+            return (0, utils_1.return_error)(new Error("Missing required parameters: view_name, ddl_source, and package_name"));
+        }
+        // Validate transport_request: required for non-$TMP packages
+        try {
+            (0, transportValidation_js_1.validateTransportRequest)(args.package_name, args.transport_request);
+        }
+        catch (error) {
+            return (0, utils_1.return_error)(error);
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const viewName = args.view_name.toUpperCase();
+        utils_1.logger.info(`Starting view creation: ${viewName}`);
+        try {
+            // Create client
+            const client = new adt_clients_1.CrudClient(connection);
+            const shouldActivate = true; // Default to true for views
+            // Validate
+            await client.validateView(viewName);
+            // Create
+            await client.createView(viewName, args.description || viewName, args.package_name, args.transport_request);
+            // Lock
+            await client.lockView(viewName);
+            const lockHandle = client.getLockHandle();
+            // Update with DDL source
+            await client.updateView(viewName, args.ddl_source, lockHandle);
+            // Check
+            await client.checkView(viewName);
+            // Unlock
+            await client.unlockView(viewName, lockHandle);
+            // Activate
+            if (shouldActivate) {
+                await client.activateView(viewName);
+            }
+            // Parse activation warnings if activation was performed
+            let activationWarnings = [];
+            if (shouldActivate && client.getActivateResult()) {
+                const activateResponse = client.getActivateResult();
+                if (typeof activateResponse.data === 'string' && activateResponse.data.includes('<chkl:messages')) {
+                    const parser = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' });
+                    const result = parser.parse(activateResponse.data);
+                    const messages = result?.['chkl:messages']?.['msg'];
+                    if (messages) {
+                        const msgArray = Array.isArray(messages) ? messages : [messages];
+                        activationWarnings = msgArray.map((msg) => `${msg['@_type']}: ${msg['shortText']?.['txt'] || 'Unknown'}`);
+                    }
+                }
+            }
+            utils_1.logger.info(`✅ CreateView completed successfully: ${viewName}`);
+            const result = {
+                success: true,
+                view_name: viewName,
+                package_name: args.package_name,
+                transport_request: args.transport_request || null,
+                type: 'DDLS',
+                message: `View ${viewName} created and activated successfully`,
+                uri: `/sap/bc/adt/ddic/ddl/sources/${(0, utils_1.encodeSapObjectName)(viewName).toLowerCase()}`,
+                steps_completed: ['validate', 'create', 'lock', 'update', 'check', 'unlock', 'activate'],
+                activation_warnings: activationWarnings.length > 0 ? activationWarnings : undefined
+            };
+            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 view ${viewName}:`, error);
+            // Check if view already exists
+            if (error.message?.includes('already exists') || error.response?.status === 409) {
+                return (0, utils_1.return_error)(new Error(`View ${viewName} 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);
+            return (0, utils_1.return_error)(new Error(`Failed to create view ${viewName}: ${errorMessage}`));
+        }
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/view/handleGetView.d.ts

@@ -0,0 +1,26 @@
+/**
+ * GetView Handler - ABAP Database View Retrieval via ADT API
+ *
+ * APPROACH:
+ * - Similar to GetTable pattern: GET request to retrieve view definition
+ * - View-specific XML structure with ddic:view namespace
+ * - Parse tables, fields, joins, and selection conditions
+ * - Support for both normal views and maintenance views
+ */
+import * as z from 'zod';
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetView";
+    readonly description: "Retrieve ABAP database view definition including tables, fields, joins, and selection conditions.";
+    readonly inputSchema: {
+        readonly view_name: z.ZodString;
+        readonly filePath: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare function handleGetView(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleGetView.d.ts.map

package/dist/handlers/view/handleGetView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetView.d.ts","sourceRoot":"","sources":["../../../src/handlers/view/handleGetView.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;;CAOlB,CAAC;AAsLX,wBAAsB,aAAa,CAAC,IAAI,EAAE,GAAG;;;;;;GAqI5C"}

package/dist/handlers/view/handleGetView.js

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * GetView Handler - ABAP Database View Retrieval via ADT API
+ *
+ * APPROACH:
+ * - Similar to GetTable pattern: GET request to retrieve view definition
+ * - View-specific XML structure with ddic:view namespace
+ * - Parse tables, fields, joins, and selection conditions
+ * - Support for both normal views and maintenance views
+ */
+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.handleGetView = handleGetView;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const writeResultToFile_1 = require("../../lib/writeResultToFile");
+const z = __importStar(require("zod"));
+exports.TOOL_DEFINITION = {
+    name: "GetView",
+    description: "Retrieve ABAP database view definition including tables, fields, joins, and selection conditions.",
+    inputSchema: {
+        view_name: z.string().describe("Name of the ABAP database view"),
+        filePath: z.string().optional().describe("Optional file path to write the result to")
+    }
+};
+/**
+ * Parse database view XML structure
+ */
+function parseViewXml(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        parseAttributeValue: true,
+        trimValues: true
+    });
+    const result = parser.parse(xml);
+    // DDIC Database View (VIEW/DV)
+    if (result['ddic:view']) {
+        const v = result['ddic:view'];
+        // Parse view tables
+        const tables = Array.isArray(v['ddic:tables']?.['ddic:table'])
+            ? v['ddic:tables']['ddic:table']
+            : v['ddic:tables']?.['ddic:table']
+                ? [v['ddic:tables']['ddic:table']]
+                : [];
+        // Parse view fields
+        const fields = Array.isArray(v['ddic:fields']?.['ddic:field'])
+            ? v['ddic:fields']['ddic:field']
+            : v['ddic:fields']?.['ddic:field']
+                ? [v['ddic:fields']['ddic:field']]
+                : [];
+        // Parse joins
+        const joins = Array.isArray(v['ddic:joins']?.['ddic:join'])
+            ? v['ddic:joins']['ddic:join']
+            : v['ddic:joins']?.['ddic:join']
+                ? [v['ddic:joins']['ddic:join']]
+                : [];
+        // Parse selection conditions
+        const conditions = Array.isArray(v['ddic:conditions']?.['ddic:condition'])
+            ? v['ddic:conditions']['ddic:condition']
+            : v['ddic:conditions']?.['ddic:condition']
+                ? [v['ddic:conditions']['ddic:condition']]
+                : [];
+        return {
+            name: v['adtcore:name'],
+            objectType: 'view',
+            description: v['adtcore:description'],
+            package: v['adtcore:packageRef']?.['adtcore:name'] || null,
+            viewType: v['ddic:viewType'] || 'database_view',
+            maintenanceAllowed: v['ddic:maintenanceAllowed'] === 'true',
+            tables: tables.map(t => ({
+                name: t['ddic:tableName'] || t['ddic:name'],
+                alias: t['ddic:alias'],
+                position: parseInt(t['ddic:position'] || '0', 10)
+            })),
+            fields: fields.map(f => ({
+                name: f['ddic:fieldName'] || f['ddic:name'],
+                table: f['ddic:tableName'],
+                alias: f['ddic:alias'],
+                dataType: f['ddic:dataType'],
+                length: parseInt(f['ddic:length'] || '0', 10),
+                decimals: parseInt(f['ddic:decimals'] || '0', 10),
+                key: f['ddic:keyFlag'] === 'true',
+                aggregation: f['ddic:aggregation'],
+                description: f['ddic:description']
+            })),
+            joins: joins.map(j => ({
+                leftTable: j['ddic:leftTable'],
+                rightTable: j['ddic:rightTable'],
+                joinType: j['ddic:joinType'] || 'INNER',
+                condition: j['ddic:condition']
+            })),
+            conditions: conditions.map(c => ({
+                field: c['ddic:fieldName'],
+                operator: c['ddic:operator'],
+                value: c['ddic:value'],
+                table: c['ddic:tableName']
+            })),
+            generatedSql: v['ddic:generatedSql']
+        };
+    }
+    // Fallback for other view types or unstructured XML
+    if (result['asx:abap']?.['asx:values']) {
+        // Handle ABAP serialized view data
+        const abapData = result['asx:abap']['asx:values'];
+        return {
+            objectType: 'view',
+            abap_structure: abapData,
+            raw: result
+        };
+    }
+    // Complete fallback: return raw XML structure
+    return {
+        raw: result,
+        note: 'Unrecognized view XML structure, returning raw parsed content'
+    };
+}
+/**
+ * Parse view object properties XML from ADT repository information system
+ */
+function parseViewPropertiesXml(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: "@_"
+    });
+    const result = parser.parse(xml);
+    if (result['opr:objectProperties']?.['opr:object']) {
+        const obj = result['opr:objectProperties']['opr:object'];
+        const properties = result['opr:objectProperties']['opr:property'] || [];
+        return {
+            name: obj['@_name'],
+            text: obj['@_text'],
+            package: obj['@_package'],
+            type: obj['@_type'],
+            expandable: obj['@_expandable'],
+            properties: Array.isArray(properties) ? properties.map(prop => ({
+                facet: prop['@_facet'],
+                name: prop['@_name'],
+                displayName: prop['@_displayName'],
+                text: prop['@_text'],
+                hasChildrenOfSameFacet: prop['@_hasChildrenOfSameFacet']
+            })) : []
+        };
+    }
+    return {
+        raw: result,
+        note: 'Unrecognized object properties XML structure'
+    };
+}
+/**
+ * Get database view contents (actual data)
+ */
+async function getViewContents(viewName, maxRows = 100) {
+    try {
+        // Use SQL query handler to get view data
+        const sqlQuery = `SELECT * FROM ${viewName}`;
+        const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/datapreview/freestyle`;
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'POST', 'default', {
+            'Content-Type': 'text/plain; charset=utf-8'
+        }, sqlQuery);
+        // Safely handle response data to avoid circular reference issues
+        let responseData;
+        try {
+            if (typeof response.data === 'object' && response.data !== null) {
+                // Try to safely serialize the object
+                responseData = JSON.parse(JSON.stringify(response.data));
+            }
+            else {
+                responseData = response.data;
+            }
+        }
+        catch (serializationError) {
+            // If serialization fails, convert to string
+            responseData = String(response.data);
+        }
+        return {
+            query: sqlQuery,
+            maxRows: maxRows,
+            data: responseData,
+            dataType: typeof response.data,
+            note: 'View contents retrieved successfully'
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            note: 'Could not retrieve view data - view might not be activated or accessible'
+        };
+    }
+}
+async function handleGetView(args) {
+    try {
+        if (!args?.view_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'View name is required');
+        }
+        const results = {
+            view_name: args.view_name,
+            timestamp: new Date().toISOString()
+        };
+        // Step 1: Detect view type and get definition
+        let definitionSuccess = false;
+        let viewType = 'unknown';
+        // Try CDS View first (modern views with DDL source)
+        try {
+            const cdsUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/ddic/ddl/sources/${(0, utils_2.encodeSapObjectName)(args.view_name)}`;
+            const cdsResponse = await (0, utils_2.makeAdtRequestWithTimeout)(cdsUrl, 'GET', 'default');
+            if (cdsResponse.status === 200 && typeof cdsResponse.data === 'string') {
+                viewType = 'CDS_VIEW';
+                results.definition = {
+                    source: 'cds_ddl',
+                    type: 'CDS View',
+                    ddl_source: cdsResponse.data,
+                    note: 'Modern CDS View with DDL source code'
+                };
+                definitionSuccess = true;
+            }
+        }
+        catch (cdsError) {
+            // Not a CDS view or not accessible, try database view
+        }
+        // Try Database View (classic views with metadata only)
+        if (!definitionSuccess) {
+            try {
+                const objectUri = `/sap/bc/adt/vit/wb/object_type/viewdv/object_name/${args.view_name}`;
+                const encodedUri = encodeURIComponent(objectUri);
+                const propertiesUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/repository/informationsystem/objectproperties/values?uri=${encodedUri}`;
+                const propertiesResponse = await (0, utils_2.makeAdtRequestWithTimeout)(propertiesUrl, 'GET', 'default');
+                if (typeof propertiesResponse.data === 'string' && propertiesResponse.data.trim().startsWith('<?xml')) {
+                    const viewProperties = parseViewPropertiesXml(propertiesResponse.data);
+                    viewType = 'DATABASE_VIEW';
+                    results.definition = {
+                        source: 'database_view_properties',
+                        type: 'Database View',
+                        ...viewProperties,
+                        note: 'Classic database view with metadata only'
+                    };
+                    definitionSuccess = true;
+                }
+            }
+            catch (dbViewError) {
+                results.definition = {
+                    error: dbViewError instanceof Error ? dbViewError.message : String(dbViewError),
+                    note: 'Could not retrieve view as CDS or Database View'
+                };
+            }
+        }
+        // Step 2: Try to get view contents (optional, may fail if view is not accessible)
+        try {
+            const maxRows = args.max_rows || 100;
+            const contentsResult = await getViewContents(args.view_name, maxRows);
+            results.contents = contentsResult;
+        }
+        catch (contentsError) {
+            results.contents = {
+                error: contentsError instanceof Error ? contentsError.message : String(contentsError),
+                note: 'Could not retrieve view contents - this is normal for some view types'
+            };
+        }
+        // Add view type to results
+        results.view_type = viewType;
+        results.detection_note = viewType === 'CDS_VIEW'
+            ? 'Modern CDS View detected - has DDL source code'
+            : viewType === 'DATABASE_VIEW'
+                ? 'Classic Database View detected - metadata only'
+                : 'Could not determine view type';
+        // Safely serialize results to avoid circular reference issues
+        let serializedResults;
+        try {
+            serializedResults = JSON.stringify(results, null, 2);
+        }
+        catch (jsonError) {
+            // If JSON serialization fails, create a safe version
+            const safeResults = {
+                view_name: results.view_name,
+                timestamp: results.timestamp,
+                view_type: results.view_type,
+                detection_note: results.detection_note,
+                definition: {
+                    source: results.definition?.source || 'unknown',
+                    type: results.definition?.type || 'unknown',
+                    note: results.definition?.note || 'No additional info',
+                    error: results.definition?.error || null
+                },
+                contents: {
+                    error: results.contents?.error || 'Serialization failed',
+                    note: 'Could not serialize view contents - possible circular reference',
+                    dataType: results.contents?.dataType || 'unknown'
+                },
+                serialization_error: jsonError instanceof Error ? jsonError.message : String(jsonError)
+            };
+            serializedResults = JSON.stringify(safeResults, null, 2);
+        }
+        const finalResult = {
+            isError: false,
+            content: [{
+                    type: "text",
+                    text: serializedResults
+                }]
+        };
+        // Write to file if path provided
+        if (args.filePath) {
+            (0, writeResultToFile_1.writeResultToFile)(serializedResults, args.filePath);
+        }
+        return finalResult;
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [{
+                    type: "text",
+                    text: `GetView failed: ${error instanceof Error ? error.message : String(error)}`
+                }]
+        };
+    }
+}

package/dist/handlers/view/handleUpdateViewSource.d.ts

@@ -0,0 +1,44 @@
+/**
+ * UpdateViewSource Handler - Update Existing CDS/Classic View DDL Source
+ *
+ * Uses ViewBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> lock -> update -> check -> unlock -> (activate)
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "UpdateViewSource";
+    readonly description: "Update DDL source code of an existing CDS View or Classic View. Locks the view, uploads new DDL source, and unlocks. Optionally activates after update. Use this to modify existing views without re-creating metadata.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly view_name: {
+                readonly type: "string";
+                readonly description: "View name (e.g., ZOK_R_TEST_0002). View must already exist.";
+            };
+            readonly ddl_source: {
+                readonly type: "string";
+                readonly description: "Complete DDL source code. CDS: include @AbapCatalog.sqlViewName and other annotations. Classic: plain 'define view' statement.";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate view after source update. Default: false. Set to true to activate immediately, or use ActivateObject for batch activation.";
+            };
+        };
+        readonly required: readonly ["view_name", "ddl_source"];
+    };
+};
+/**
+ * Main handler for UpdateViewSource MCP tool
+ *
+ * Uses ViewBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleUpdateViewSource(params: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleUpdateViewSource.d.ts.map

package/dist/handlers/view/handleUpdateViewSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleUpdateViewSource.d.ts","sourceRoot":"","sources":["../../../src/handlers/view/handleUpdateViewSource.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;CAqBlB,CAAC;AASX;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,GAAG;;;;;;GA6GvD"}