@mcp-abap-adt/adt-clients 0.1.0

package/dist/core/interface/create.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Interface create operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInterface = createInterface;
+const internalUtils_1 = require("../../utils/internalUtils");
+const sessionUtils_1 = require("../../utils/sessionUtils");
+const lock_1 = require("./lock");
+const unlock_1 = require("./unlock");
+const activation_1 = require("./activation");
+const systemInfo_1 = require("../shared/systemInfo");
+/**
+ * Generate minimal interface source code if not provided
+ */
+function generateInterfaceTemplate(interfaceName, description) {
+    return `INTERFACE ${interfaceName}
+  PUBLIC.
+
+  " ${description}
+
+  METHODS: get_value
+    RETURNING VALUE(rv_result) TYPE string.
+
+ENDINTERFACE.`;
+}
+/**
+ * Create interface object with metadata
+ */
+async function createInterfaceObject(connection, interfaceName, description, packageName, transportRequest, sessionId, masterSystem, responsible) {
+    // Get masterSystem and responsible (only for cloud systems)
+    // On cloud, getSystemInformation returns systemID and userName
+    // On on-premise, it returns null, so we don't add these attributes
+    let finalMasterSystem = masterSystem;
+    let finalResponsible = responsible;
+    const systemInfo = await (0, systemInfo_1.getSystemInformation)(connection);
+    if (systemInfo) {
+        finalMasterSystem = finalMasterSystem || systemInfo.systemID;
+        finalResponsible = finalResponsible || systemInfo.userName;
+    }
+    // Only use masterSystem from getSystemInformation (cloud), not from env
+    // username can fallback to env if not provided
+    finalResponsible = finalResponsible || process.env.SAP_USERNAME || process.env.SAP_USER || '';
+    const masterSystemAttr = finalMasterSystem ? ` adtcore:masterSystem="${finalMasterSystem}"` : '';
+    const responsibleAttr = finalResponsible ? ` adtcore:responsible="${finalResponsible}"` : '';
+    const payload = `<?xml version="1.0" encoding="UTF-8"?><intf:abapInterface xmlns:intf="http://www.sap.com/adt/oo/interfaces" xmlns:adtcore="http://www.sap.com/adt/core" adtcore:description="${description}" adtcore:language="EN" adtcore:name="${interfaceName}" adtcore:type="INTF/OI" adtcore:masterLanguage="EN"${masterSystemAttr}${responsibleAttr}>
+
+
+
+  <adtcore:packageRef adtcore:name="${packageName}"/>
+
+
+
+</intf:abapInterface>`;
+    const url = `/sap/bc/adt/oo/interfaces`;
+    const params = transportRequest ? `?corrNr=${transportRequest}` : '';
+    return (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url + params, 'POST', sessionId, payload, {
+        'Content-Type': 'application/vnd.sap.adt.oo.interfaces.v5+xml',
+        'Accept': 'application/vnd.sap.adt.oo.interfaces.v5+xml'
+    });
+}
+/**
+ * Upload interface source code
+ */
+async function uploadInterfaceSource(connection, interfaceName, sourceCode, lockHandle, corrNr, sessionId) {
+    let url = `/sap/bc/adt/oo/interfaces/${(0, internalUtils_1.encodeSapObjectName)(interfaceName)}/source/main?lockHandle=${lockHandle}`;
+    if (corrNr) {
+        url += `&corrNr=${corrNr}`;
+    }
+    await (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'PUT', sessionId, sourceCode, { 'Content-Type': 'text/plain; charset=utf-8' });
+}
+/**
+ * Create ABAP interface
+ * Full workflow: create object -> lock -> upload source -> unlock -> activate
+ */
+async function createInterface(connection, params) {
+    if (!params.interface_name || !params.package_name) {
+        throw new Error('interface_name and package_name are required');
+    }
+    const finalDescription = params.description || params.interface_name;
+    const finalSourceCode = params.source_code || generateInterfaceTemplate(params.interface_name, finalDescription);
+    const sessionId = (0, sessionUtils_1.generateSessionId)();
+    let lockHandle;
+    try {
+        // Step 1: Create interface object with metadata
+        const createResponse = await createInterfaceObject(connection, params.interface_name, finalDescription, params.package_name, params.transport_request, sessionId, params.master_system, params.responsible);
+        // Step 2: Lock interface
+        const lockData = await (0, lock_1.lockInterface)(connection, params.interface_name, sessionId);
+        lockHandle = lockData.lockHandle;
+        const corrNr = lockData.corrNr;
+        // Step 3: Upload source code
+        await uploadInterfaceSource(connection, params.interface_name, finalSourceCode, lockHandle, corrNr, sessionId);
+        // Step 4: Unlock interface
+        await (0, unlock_1.unlockInterface)(connection, params.interface_name, lockHandle, sessionId);
+        lockHandle = undefined;
+        // Step 5: Activate interface (optional)
+        const shouldActivate = params.activate !== false;
+        if (shouldActivate) {
+            await (0, activation_1.activateInterface)(connection, params.interface_name, sessionId);
+        }
+        // Return the real response from SAP (from initial POST)
+        return createResponse;
+    }
+    catch (error) {
+        // Attempt to unlock if we have a lock handle
+        if (lockHandle) {
+            try {
+                await (0, unlock_1.unlockInterface)(connection, params.interface_name, lockHandle, sessionId);
+            }
+            catch (unlockError) {
+                // Ignore unlock errors
+            }
+        }
+        const errorMessage = error.response?.data
+            ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+            : error.message;
+        throw new Error(`Failed to create interface ${params.interface_name}: ${errorMessage}`);
+    }
+}

package/dist/core/interface/delete.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Interface delete operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+export interface DeleteInterfaceParams {
+    interface_name: string;
+    transport_request?: string;
+    check_before_delete?: boolean;
+}
+/**
+ * Check if interface can be deleted
+ */
+export declare function checkInterfaceDeletion(connection: AbapConnection, interfaceName: string): Promise<AxiosResponse>;
+/**
+ * Delete ABAP interface
+ * Optionally checks deletion before deleting (like Eclipse ADT)
+ */
+export declare function deleteInterface(connection: AbapConnection, params: DeleteInterfaceParams): Promise<AxiosResponse>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/core/interface/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/core/interface/delete.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC,CAWxB;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,aAAa,CAAC,CAuBxB"}

package/dist/core/interface/delete.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Interface delete operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkInterfaceDeletion = checkInterfaceDeletion;
+exports.deleteInterface = deleteInterface;
+const delete_1 = require("../delete");
+/**
+ * Check if interface can be deleted
+ */
+async function checkInterfaceDeletion(connection, interfaceName) {
+    if (!interfaceName) {
+        throw new Error('interface_name is required');
+    }
+    const checkParams = {
+        object_name: interfaceName,
+        object_type: 'INTF/OI'
+    };
+    return await (0, delete_1.checkDeletion)(connection, checkParams);
+}
+/**
+ * Delete ABAP interface
+ * Optionally checks deletion before deleting (like Eclipse ADT)
+ */
+async function deleteInterface(connection, params) {
+    if (!params.interface_name) {
+        throw new Error('interface_name is required');
+    }
+    // Optional: Check deletion before deleting (like Eclipse ADT)
+    // This can be useful to verify object is deletable and get dependencies
+    if (params.check_before_delete !== false) {
+        try {
+            await checkInterfaceDeletion(connection, params.interface_name);
+        }
+        catch (error) {
+            // If check fails, still attempt deletion (check is optional)
+            // Log warning but continue
+        }
+    }
+    const deleteParams = {
+        object_name: params.interface_name,
+        object_type: 'INTF/OI',
+        transport_request: params.transport_request
+    };
+    return await (0, delete_1.deleteObject)(connection, deleteParams);
+}

package/dist/core/interface/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Interface operations - exports
+ */
+export * from './types';
+export * from './create';
+export * from './update';
+export * from './read';
+export * from './lock';
+export * from './unlock';
+export * from './activation';
+export * from './check';
+export * from './validation';
+export * from './delete';
+export { InterfaceBuilder, type InterfaceBuilderConfig, type InterfaceBuilderLogger, type InterfaceBuilderState } from './InterfaceBuilder';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/interface/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/interface/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,KAAK,sBAAsB,EAAE,KAAK,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/core/interface/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Interface operations - exports
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceBuilder = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./create"), exports);
+__exportStar(require("./update"), exports);
+__exportStar(require("./read"), exports);
+__exportStar(require("./lock"), exports);
+__exportStar(require("./unlock"), exports);
+__exportStar(require("./activation"), exports);
+__exportStar(require("./check"), exports);
+__exportStar(require("./validation"), exports);
+__exportStar(require("./delete"), exports);
+var InterfaceBuilder_1 = require("./InterfaceBuilder");
+Object.defineProperty(exports, "InterfaceBuilder", { enumerable: true, get: function () { return InterfaceBuilder_1.InterfaceBuilder; } });

package/dist/core/interface/lock.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Interface lock operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Lock interface for modification
+ * Returns lock handle and transport number
+ */
+export declare function lockInterface(connection: AbapConnection, interfaceName: string, sessionId: string): Promise<{
+    lockHandle: string;
+    corrNr?: string;
+}>;
+/**
+ * Lock interface for editing (for update)
+ * Returns lock handle and transport number
+ */
+export declare function lockInterfaceForUpdate(connection: AbapConnection, interfaceName: string, sessionId: string): Promise<{
+    response: AxiosResponse;
+    lockHandle: string;
+    corrNr?: string;
+}>;
+//# sourceMappingURL=lock.d.ts.map

package/dist/core/interface/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../src/core/interface/lock.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAKtC;;;GAGG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAuBlD;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAmB3E"}

package/dist/core/interface/lock.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Interface lock operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockInterface = lockInterface;
+exports.lockInterfaceForUpdate = lockInterfaceForUpdate;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const internalUtils_1 = require("../../utils/internalUtils");
+const sessionUtils_1 = require("../../utils/sessionUtils");
+/**
+ * Lock interface for modification
+ * Returns lock handle and transport number
+ */
+async function lockInterface(connection, interfaceName, sessionId) {
+    const url = `/sap/bc/adt/oo/interfaces/${(0, internalUtils_1.encodeSapObjectName)(interfaceName).toLowerCase()}?_action=LOCK&accessMode=MODIFY`;
+    const headers = {
+        'Accept': 'application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.lock.result;q=0.8, application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.lock.result2;q=0.9'
+    };
+    const response = await (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'POST', sessionId, null, headers);
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: ''
+    });
+    const lockData = parser.parse(response.data);
+    const lockHandle = lockData['asx:abap']?.['asx:values']?.['DATA']?.['LOCK_HANDLE'];
+    const corrNr = lockData['asx:abap']?.['asx:values']?.['DATA']?.['CORRNR'];
+    if (!lockHandle) {
+        throw new Error('Failed to acquire lock handle from response');
+    }
+    return { lockHandle, corrNr };
+}
+/**
+ * Lock interface for editing (for update)
+ * Returns lock handle and transport number
+ */
+async function lockInterfaceForUpdate(connection, interfaceName, sessionId) {
+    const url = `/sap/bc/adt/oo/interfaces/${(0, internalUtils_1.encodeSapObjectName)(interfaceName).toLowerCase()}?_action=LOCK&accessMode=MODIFY`;
+    const headers = {
+        'Accept': 'application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.lock.result;q=0.8, application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.lock.result2;q=0.9'
+    };
+    const response = await (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'POST', sessionId, null, headers);
+    const parser = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' });
+    const result = parser.parse(response.data);
+    const lockHandle = result?.['asx:abap']?.['asx:values']?.['DATA']?.['LOCK_HANDLE'];
+    const corrNr = result?.['asx:abap']?.['asx:values']?.['DATA']?.['CORRNR'];
+    if (!lockHandle) {
+        throw new Error('Failed to obtain lock handle from SAP. Interface may be locked by another user.');
+    }
+    return { response, lockHandle, corrNr };
+}

package/dist/core/interface/read.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Interface read operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Get ABAP interface metadata (without source code)
+ */
+export declare function getInterfaceMetadata(connection: AbapConnection, interfaceName: string): Promise<AxiosResponse>;
+/**
+ * Get ABAP interface source code
+ */
+export declare function getInterfaceSource(connection: AbapConnection, interfaceName: string): Promise<AxiosResponse>;
+/**
+ * Get ABAP interface (source code by default for backward compatibility)
+ * @deprecated Use getInterfaceSource() or getInterfaceMetadata() instead
+ */
+export declare function getInterface(connection: AbapConnection, interfaceName: string): Promise<AxiosResponse>;
+/**
+ * Get transport request for ABAP interface
+ * @param connection - SAP connection
+ * @param interfaceName - Interface name
+ * @returns Transport request information
+ */
+export declare function getInterfaceTransport(connection: AbapConnection, interfaceName: string): Promise<AxiosResponse>;
+//# sourceMappingURL=read.d.ts.map

package/dist/core/interface/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../src/core/interface/read.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAc,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAKtC;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC,CAExB;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC,CAExB;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC,CAExB;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC,CAaxB"}

package/dist/core/interface/read.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Interface read operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInterfaceMetadata = getInterfaceMetadata;
+exports.getInterfaceSource = getInterfaceSource;
+exports.getInterface = getInterface;
+exports.getInterfaceTransport = getInterfaceTransport;
+const connection_1 = require("@mcp-abap-adt/connection");
+const internalUtils_1 = require("../../utils/internalUtils");
+const readMetadata_1 = require("../shared/readMetadata");
+const readSource_1 = require("../shared/readSource");
+/**
+ * Get ABAP interface metadata (without source code)
+ */
+async function getInterfaceMetadata(connection, interfaceName) {
+    return (0, readMetadata_1.readObjectMetadata)(connection, 'interface', interfaceName);
+}
+/**
+ * Get ABAP interface source code
+ */
+async function getInterfaceSource(connection, interfaceName) {
+    return (0, readSource_1.readObjectSource)(connection, 'interface', interfaceName);
+}
+/**
+ * Get ABAP interface (source code by default for backward compatibility)
+ * @deprecated Use getInterfaceSource() or getInterfaceMetadata() instead
+ */
+async function getInterface(connection, interfaceName) {
+    return getInterfaceSource(connection, interfaceName);
+}
+/**
+ * Get transport request for ABAP interface
+ * @param connection - SAP connection
+ * @param interfaceName - Interface name
+ * @returns Transport request information
+ */
+async function getInterfaceTransport(connection, interfaceName) {
+    const baseUrl = await connection.getBaseUrl();
+    const encodedName = (0, internalUtils_1.encodeSapObjectName)(interfaceName);
+    const url = `${baseUrl}/sap/bc/adt/oo/interfaces/${encodedName}/transport`;
+    return connection.makeAdtRequest({
+        url,
+        method: 'GET',
+        timeout: (0, connection_1.getTimeout)('default'),
+        headers: {
+            'Accept': 'application/vnd.sap.adt.transportorganizer.v1+xml'
+        }
+    });
+}

package/dist/core/interface/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Interface types
+ */
+export interface CreateInterfaceParams {
+    interface_name: string;
+    description?: string;
+    package_name: string;
+    transport_request?: string;
+    master_system?: string;
+    responsible?: string;
+    source_code?: string;
+    activate?: boolean;
+}
+export interface UpdateInterfaceSourceParams {
+    interface_name: string;
+    source_code: string;
+    activate?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/interface/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/interface/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,2BAA2B;IAC1C,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/dist/core/interface/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Interface types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/interface/unlock.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Interface unlock operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Unlock interface
+ * Must use same session and lock handle from lock operation
+ */
+export declare function unlockInterface(connection: AbapConnection, interfaceName: string, lockHandle: string, sessionId: string): Promise<AxiosResponse>;
+//# sourceMappingURL=unlock.d.ts.map

package/dist/core/interface/unlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlock.d.ts","sourceRoot":"","sources":["../../../src/core/interface/unlock.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAItC;;;GAGG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CAkCxB"}

package/dist/core/interface/unlock.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Interface unlock operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlockInterface = unlockInterface;
+const internalUtils_1 = require("../../utils/internalUtils");
+const sessionUtils_1 = require("../../utils/sessionUtils");
+/**
+ * Unlock interface
+ * Must use same session and lock handle from lock operation
+ */
+async function unlockInterface(connection, interfaceName, lockHandle, sessionId) {
+    const url = `/sap/bc/adt/oo/interfaces/${(0, internalUtils_1.encodeSapObjectName)(interfaceName)}?_action=UNLOCK&lockHandle=${lockHandle}`;
+    try {
+        const response = await (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'POST', sessionId, '', { 'Content-Type': 'application/x-www-form-urlencoded' });
+        return response;
+    }
+    catch (error) {
+        // If response is not returned (e.g., object locked by another user, network error),
+        // provide more context in the error message
+        if (!error.response) {
+            throw new Error(`Failed to unlock interface ${interfaceName}: No response from server. ` +
+                `Lock handle: ${lockHandle.substring(0, 10)}..., Session: ${sessionId.substring(0, 10)}... ` +
+                `The interface may be locked by another user or session may be invalid.`);
+        }
+        // If we have a response, include its status and data in the error
+        const status = error.response?.status;
+        const statusText = status ? `HTTP ${status}` : 'HTTP ?';
+        const errorData = error.response?.data
+            ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+            : error.message;
+        throw new Error(`Failed to unlock interface ${interfaceName} (${statusText}): ${errorData}`);
+    }
+}

package/dist/core/interface/update.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Interface update operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+import { UpdateInterfaceSourceParams } from './types';
+/**
+ * Update interface source code
+ * Full workflow: lock -> upload source -> unlock -> activate (optional)
+ */
+export declare function updateInterfaceSource(connection: AbapConnection, params: UpdateInterfaceSourceParams): Promise<AxiosResponse>;
+//# sourceMappingURL=update.d.ts.map

package/dist/core/interface/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/core/interface/update.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAOtC,OAAO,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AA0BtD;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,aAAa,CAAC,CA2DxB"}

package/dist/core/interface/update.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Interface update operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateInterfaceSource = updateInterfaceSource;
+const internalUtils_1 = require("../../utils/internalUtils");
+const sessionUtils_1 = require("../../utils/sessionUtils");
+const lock_1 = require("./lock");
+const unlock_1 = require("./unlock");
+const activation_1 = require("./activation");
+/**
+ * Upload interface source code (for update)
+ */
+async function uploadInterfaceSourceForUpdate(connection, interfaceName, sourceCode, lockHandle, sessionId, corrNr) {
+    let url = `/sap/bc/adt/oo/interfaces/${(0, internalUtils_1.encodeSapObjectName)(interfaceName).toLowerCase()}/source/main?lockHandle=${lockHandle}`;
+    if (corrNr) {
+        url += `&corrNr=${corrNr}`;
+    }
+    const headers = {
+        'Content-Type': 'text/plain; charset=utf-8',
+        'Accept': 'text/plain'
+    };
+    return await (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'PUT', sessionId, sourceCode, headers);
+}
+/**
+ * Update interface source code
+ * Full workflow: lock -> upload source -> unlock -> activate (optional)
+ */
+async function updateInterfaceSource(connection, params) {
+    const interfaceName = params.interface_name.toUpperCase();
+    const sessionId = (0, sessionUtils_1.generateSessionId)();
+    let lockHandle = null;
+    try {
+        // Step 1: Lock the interface
+        const lockResult = await (0, lock_1.lockInterfaceForUpdate)(connection, interfaceName, sessionId);
+        lockHandle = lockResult.lockHandle;
+        const corrNr = lockResult.corrNr;
+        // Step 2: Upload new source code
+        await uploadInterfaceSourceForUpdate(connection, interfaceName, params.source_code, lockHandle, sessionId, corrNr);
+        // Step 3: Unlock the interface
+        await (0, unlock_1.unlockInterface)(connection, interfaceName, lockHandle, sessionId);
+        lockHandle = null;
+        // Step 4: Activate the interface (optional)
+        const shouldActivate = params.activate === true;
+        if (shouldActivate) {
+            await (0, activation_1.activateInterface)(connection, interfaceName, sessionId);
+        }
+        // Return success response
+        return {
+            data: {
+                success: true,
+                interface_name: interfaceName,
+                type: 'INTF/OI',
+                message: shouldActivate
+                    ? `Interface ${interfaceName} source updated and activated successfully`
+                    : `Interface ${interfaceName} source updated successfully (not activated)`,
+                uri: `/sap/bc/adt/oo/interfaces/${(0, internalUtils_1.encodeSapObjectName)(interfaceName).toLowerCase()}`,
+                source_size_bytes: params.source_code.length
+            },
+            status: 200,
+            statusText: 'OK',
+            headers: {},
+            config: {}
+        };
+    }
+    catch (error) {
+        // CRITICAL: Always try to unlock on error to prevent locked objects
+        if (lockHandle) {
+            try {
+                await (0, unlock_1.unlockInterface)(connection, interfaceName, lockHandle, sessionId);
+            }
+            catch (unlockError) {
+                // Ignore unlock errors
+            }
+        }
+        const errorMessage = error.response?.data
+            ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+            : error.message;
+        throw new Error(`Failed to update interface ${interfaceName}: ${errorMessage}`);
+    }
+}

package/dist/core/interface/validation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interface validation
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { ValidationResult } from '../shared/validation';
+/**
+ * Validate interface name
+ */
+export declare function validateInterfaceName(connection: AbapConnection, interfaceName: string, description?: string): Promise<ValidationResult>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/core/interface/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/core/interface/validation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAsB,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE5E;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAQ3B"}

package/dist/core/interface/validation.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Interface validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInterfaceName = validateInterfaceName;
+const validation_1 = require("../shared/validation");
+/**
+ * Validate interface name
+ */
+async function validateInterfaceName(connection, interfaceName, description) {
+    const params = {};
+    if (description) {
+        params.description = description;
+    }
+    return (0, validation_1.validateObjectName)(connection, 'INTF/OI', interfaceName, params);
+}