@mcp-abap-adt/adt-clients 7.2.0 → 7.3.0

package/dist/core/messageClass/AdtMessageClassMessage.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * AdtMessageClassMessage — read-modify-write operations for a single message
+ * within a Message Class (MSAG/N).
+ *
+ * Implements IAdtObject<IMessageClassMessageConfig, IMessageClassMessageState>.
+ *
+ * Operation chains:
+ * - read:   GET class XML → find message by msgno → return state.message
+ * - create/update: GET class → merge message → stateful → lockMessage (MH) +
+ *           lockClassForMessage (CH) → PUT full class XML (message with
+ *           mc:lockhandle=MH, lockHandle=CH) → unlockAllMessages →
+ *           unlock class (CH) → stateless
+ * - delete: GET class → stateful → lockMessage (MH) + lockClassForMessage (CH)
+ *           → PUT class XML with target message as <mc:deletedmessages
+ *           mc:lockhandle=MH>, all other messages as <mc:messages> →
+ *           unlockAllMessages → unlock class (CH) → stateless.
+ *           (SAP does NOT delete omitted messages on PUT — <mc:deletedmessages>
+ *           is the correct mechanism. A message-level DELETE /messages/{no}
+ *           returns 423 and is NOT used.)
+ *
+ * Unsupported: activate, check, validate, lock, unlock, getVersions,
+ * getVersionSource, readTransport → throwUnsupportedOperation.
+ *
+ * transport / corrNr: not sent yet — Task 6.2 will wire it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdtMessageClassMessage = void 0;
+const interfaces_1 = require("@mcp-abap-adt/interfaces");
+const contentTypes_1 = require("../../constants/contentTypes");
+const internalUtils_1 = require("../../utils/internalUtils");
+const timeouts_1 = require("../../utils/timeouts");
+const unsupported_1 = require("../shared/unsupported");
+const lock_1 = require("./lock");
+const read_1 = require("./read");
+const unlock_1 = require("./unlock");
+const xml_1 = require("./xml");
+const BASE = '/sap/bc/adt/messageclass';
+class AdtMessageClassMessage {
+    connection;
+    logger;
+    objectType = 'MessageClassMessage';
+    constructor(connection, logger) {
+        this.connection = connection;
+        this.logger = logger;
+    }
+    // ── read ──────────────────────────────────────────────────────────────────
+    /**
+     * Read a single message from the parent class.
+     * Returns undefined when the parent class itself is absent (404).
+     * Throws OBJECT_NOT_FOUND when the class exists but the message number is absent.
+     */
+    async read(config) {
+        if (!config.className)
+            throw new Error('className is required');
+        if (!config.msgno)
+            throw new Error('msgno is required');
+        const no = String(config.msgno);
+        try {
+            const response = await (0, read_1.getMessageClassSource)(this.connection, config.className);
+            const cls = (0, xml_1.parseMessageClass)(String(response.data));
+            const message = cls.messages.find((m) => m.msgno === no);
+            if (!message) {
+                const e = new interfaces_1.AdtOperationError(`Message ${no} not found in class ${config.className}`);
+                e.code = interfaces_1.AdtObjectErrorCodes.OBJECT_NOT_FOUND;
+                throw e;
+            }
+            return { message, errors: [] };
+        }
+        catch (error) {
+            const e = error;
+            if (e.response?.status === 404) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    // ── create / update (upsert) ───────────────────────────────────────────────
+    /**
+     * Create or upsert a single message in the parent class.
+     * Delegates to the update logic.
+     */
+    async create(config, _options) {
+        return this._upsertMessage(config);
+    }
+    /**
+     * Update (upsert) a single message in the parent class.
+     * Full chain: GET class → merge message → stateful → LOCK_MSG + class LOCK →
+     * PUT class XML → unlock class → unlockAllMessages → stateless.
+     */
+    async update(config, _options) {
+        return this._upsertMessage(config);
+    }
+    async _upsertMessage(config) {
+        if (!config.className)
+            throw new Error('className is required');
+        if (!config.msgno)
+            throw new Error('msgno is required');
+        const name = config.className;
+        const no = String(config.msgno);
+        // 1. Read current class state to preserve all messages
+        const response = await (0, read_1.getMessageClassSource)(this.connection, name);
+        const cls = (0, xml_1.parseMessageClass)(String(response.data));
+        // 2. Merge/set the message in the messages array
+        const existingIdx = cls.messages.findIndex((m) => m.msgno === no);
+        if (existingIdx >= 0) {
+            // Update existing message — only override fields when explicitly provided in config
+            cls.messages[existingIdx] = {
+                ...cls.messages[existingIdx],
+                ...(config.msgtext !== undefined ? { msgtext: config.msgtext } : {}),
+                ...(config.selfExplanatory !== undefined
+                    ? { selfExplanatory: config.selfExplanatory }
+                    : {}),
+                ...(config.description !== undefined
+                    ? { description: config.description }
+                    : {}),
+            };
+        }
+        else {
+            // Add new message with all authorable fields
+            cls.messages.push({
+                msgno: no,
+                msgtext: config.msgtext ?? '',
+                ...(config.selfExplanatory !== undefined
+                    ? { selfExplanatory: config.selfExplanatory }
+                    : {}),
+                ...(config.description !== undefined
+                    ? { description: config.description }
+                    : {}),
+            });
+        }
+        let messageLockHandle;
+        let classLockHandle;
+        try {
+            this.logger?.info?.('upsertMessage: stateful');
+            this.connection.setSessionType('stateful');
+            // 3. Lock individual message
+            this.logger?.info?.('upsertMessage: lockMessage');
+            messageLockHandle = await (0, lock_1.lockMessage)(this.connection, name, no);
+            // 4. Lock class for message save
+            this.logger?.info?.('upsertMessage: lockClassForMessage');
+            classLockHandle = await (0, lock_1.lockClassForMessage)(this.connection, name, no);
+            // 5. PUT full class XML with message lock handle embedded
+            this.logger?.info?.('upsertMessage: PUT');
+            const xmlBody = (0, xml_1.buildMessageClassXml)(cls, {
+                messageLockHandles: { [no]: messageLockHandle },
+            });
+            const encoded = (0, internalUtils_1.encodeSapObjectName)(name.toLowerCase());
+            const updateResult = await this.connection.makeAdtRequest({
+                url: `${BASE}/${encoded}?lockHandle=${encodeURIComponent(classLockHandle)}`,
+                method: 'PUT',
+                timeout: (0, timeouts_1.getTimeout)('default'),
+                data: xmlBody,
+                headers: { 'Content-Type': contentTypes_1.MESSAGE_CLASS_UPDATE_CONTENT_TYPE },
+            });
+            // 6. Release the message lock first, then unlock the whole class last —
+            //    the class edit-lock must be the final release of the process.
+            this.logger?.info?.('upsertMessage: unlockAllMessages');
+            await (0, unlock_1.unlockAllMessages)(this.connection, name, no);
+            messageLockHandle = undefined;
+            // 7. Unlock the whole class (final release)
+            this.logger?.info?.('upsertMessage: unlock class');
+            await (0, unlock_1.unlockMessageClass)(this.connection, name, classLockHandle);
+            classLockHandle = undefined;
+            // 8. Back to stateless
+            this.connection.setSessionType('stateless');
+            this.logger?.info?.('upsertMessage: done');
+            return { updateResult, errors: [] };
+        }
+        catch (error) {
+            // Always clean up locks and reset session on failure — release the
+            // message lock first, then the class (final release), mirroring the happy path.
+            if (messageLockHandle) {
+                try {
+                    await (0, unlock_1.unlockAllMessages)(this.connection, name, no);
+                }
+                catch (ue) {
+                    this.logger?.warn?.('Failed to unlock messages during cleanup:', (0, internalUtils_1.safeErrorMessage)(ue));
+                }
+            }
+            if (classLockHandle) {
+                try {
+                    await (0, unlock_1.unlockMessageClass)(this.connection, name, classLockHandle);
+                }
+                catch (ue) {
+                    this.logger?.warn?.('Failed to unlock class during cleanup:', (0, internalUtils_1.safeErrorMessage)(ue));
+                }
+            }
+            this.connection.setSessionType('stateless');
+            this.logger?.error('upsertMessage failed:', (0, internalUtils_1.safeErrorMessage)(error));
+            throw error;
+        }
+    }
+    // ── delete ────────────────────────────────────────────────────────────────
+    /**
+     * Delete a single message from the parent class.
+     *
+     * SAP does NOT remove messages that are merely omitted from a class PUT — it
+     * only upserts what is present.  The correct mechanism is to PUT the class
+     * with the target message placed in <mc:deletedmessages> (carrying its own
+     * message lock handle), while every other message remains in <mc:messages>.
+     *
+     * Chain: GET class → stateful → lockMessage (MH) + lockClassForMessage (CH)
+     * → PUT class XML with target in <mc:deletedmessages mc:lockhandle=MH>,
+     * remaining messages in <mc:messages> → unlockAllMessages →
+     * unlock class (CH) → stateless.
+     */
+    async delete(config) {
+        if (!config.className)
+            throw new Error('className is required');
+        if (!config.msgno)
+            throw new Error('msgno is required');
+        const name = config.className;
+        const no = String(config.msgno);
+        // 1. Read current class state — keep ALL messages (including the one being
+        //    deleted) so the builder can emit <mc:deletedmessages> for the target
+        const response = await (0, read_1.getMessageClassSource)(this.connection, name);
+        const cls = (0, xml_1.parseMessageClass)(String(response.data));
+        let messageLockHandle;
+        let classLockHandle;
+        try {
+            this.logger?.info?.('deleteMessage: stateful');
+            this.connection.setSessionType('stateful');
+            // 2. Lock the individual message (required for <mc:deletedmessages>)
+            this.logger?.info?.('deleteMessage: lockMessage');
+            messageLockHandle = await (0, lock_1.lockMessage)(this.connection, name, no);
+            // 3. Lock the class for a message-save (msgNo + onSave=X)
+            this.logger?.info?.('deleteMessage: lockClassForMessage');
+            classLockHandle = await (0, lock_1.lockClassForMessage)(this.connection, name, no);
+            // 4. PUT: target message → <mc:deletedmessages>; all others → <mc:messages>
+            this.logger?.info?.('deleteMessage: PUT');
+            const xmlBody = (0, xml_1.buildMessageClassXml)(cls, {
+                deletedMsgnos: [no],
+                messageLockHandles: { [no]: messageLockHandle },
+            });
+            const encoded = (0, internalUtils_1.encodeSapObjectName)(name.toLowerCase());
+            const deleteResult = await this.connection.makeAdtRequest({
+                url: `${BASE}/${encoded}?lockHandle=${encodeURIComponent(classLockHandle)}`,
+                method: 'PUT',
+                timeout: (0, timeouts_1.getTimeout)('default'),
+                data: xmlBody,
+                headers: { 'Content-Type': contentTypes_1.MESSAGE_CLASS_UPDATE_CONTENT_TYPE },
+            });
+            // 5. Release the message lock first, then unlock the whole class last.
+            this.logger?.info?.('deleteMessage: unlockAllMessages');
+            await (0, unlock_1.unlockAllMessages)(this.connection, name, no);
+            messageLockHandle = undefined;
+            // 6. Unlock the whole class (final release)
+            this.logger?.info?.('deleteMessage: unlock class');
+            await (0, unlock_1.unlockMessageClass)(this.connection, name, classLockHandle);
+            classLockHandle = undefined;
+            this.connection.setSessionType('stateless');
+            this.logger?.info?.('deleteMessage: done');
+            return { deleteResult, errors: [] };
+        }
+        catch (error) {
+            // Release the message lock first, then the class (final release).
+            if (messageLockHandle) {
+                try {
+                    await (0, unlock_1.unlockAllMessages)(this.connection, name, no);
+                }
+                catch (ue) {
+                    this.logger?.warn?.('Failed to unlock messages during cleanup:', (0, internalUtils_1.safeErrorMessage)(ue));
+                }
+            }
+            if (classLockHandle) {
+                try {
+                    await (0, unlock_1.unlockMessageClass)(this.connection, name, classLockHandle);
+                }
+                catch (ue) {
+                    this.logger?.warn?.('Failed to unlock class during cleanup:', (0, internalUtils_1.safeErrorMessage)(ue));
+                }
+            }
+            this.connection.setSessionType('stateless');
+            this.logger?.error('deleteMessage failed:', (0, internalUtils_1.safeErrorMessage)(error));
+            throw error;
+        }
+    }
+    // ── readMetadata ───────────────────────────────────────────────────────────
+    /** Delegates to read() — individual messages have no separate metadata endpoint. */
+    async readMetadata(config) {
+        const state = await this.read(config);
+        if (!state) {
+            throw new Error(`Message ${config.msgno} not found in class ${config.className}`);
+        }
+        return state;
+    }
+    // ── unsupported operations ─────────────────────────────────────────────────
+    async validate(_config) {
+        (0, unsupported_1.throwUnsupportedOperation)('validate', 'message class message');
+    }
+    async activate(_config) {
+        (0, unsupported_1.throwUnsupportedOperation)('activate', 'message class message');
+    }
+    async check(_config) {
+        (0, unsupported_1.throwUnsupportedOperation)('check', 'message class message');
+    }
+    async readTransport(_config) {
+        (0, unsupported_1.throwUnsupportedOperation)('readTransport', 'message class message');
+    }
+    async lock(_config) {
+        (0, unsupported_1.throwUnsupportedOperation)('lock', 'message class message');
+    }
+    async unlock(_config, _lockHandle) {
+        (0, unsupported_1.throwUnsupportedOperation)('unlock', 'message class message');
+    }
+    async getVersions(_config) {
+        (0, unsupported_1.throwUnsupportedOperation)('getVersions', 'message class message');
+    }
+    async getVersionSource(_contentUri) {
+        (0, unsupported_1.throwUnsupportedOperation)('getVersionSource', 'message class message');
+    }
+}
+exports.AdtMessageClassMessage = AdtMessageClassMessage;

package/dist/core/messageClass/create.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Message class create operations
+ */
+import type { IAbapConnection, IAdtResponse } from '@mcp-abap-adt/interfaces';
+import type { ICreateMessageClassParams } from './types';
+/**
+ * Create a new message class (shell — no messages yet).
+ * POST /sap/bc/adt/messageclass with Content-Type application/xml.
+ *
+ * corrNr (transport) is intentionally omitted here — the local/no-transport
+ * path is the only one confirmed by probe. Task 6.2 will wire it for
+ * transportable packages once a corrNr probe succeeds.
+ */
+export declare function createMessageClass(connection: IAbapConnection, params: ICreateMessageClassParams): Promise<IAdtResponse>;
+//# sourceMappingURL=create.d.ts.map

package/dist/core/messageClass/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/core/messageClass/create.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE9E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAKzD;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,eAAe,EAC3B,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,YAAY,CAAC,CAsBvB"}

package/dist/core/messageClass/create.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Message class create operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageClass = createMessageClass;
+const timeouts_1 = require("../../utils/timeouts");
+const xml_1 = require("./xml");
+const BASE = '/sap/bc/adt/messageclass';
+/**
+ * Create a new message class (shell — no messages yet).
+ * POST /sap/bc/adt/messageclass with Content-Type application/xml.
+ *
+ * corrNr (transport) is intentionally omitted here — the local/no-transport
+ * path is the only one confirmed by probe. Task 6.2 will wire it for
+ * transportable packages once a corrNr probe succeeds.
+ */
+async function createMessageClass(connection, params) {
+    // Emit BOTH adtcore:language and adtcore:masterLanguage (like domain/class),
+    // both set to the resolved language.
+    const lang = params.master_language ?? 'EN';
+    const xmlBody = (0, xml_1.buildMessageClassXml)({
+        name: params.name.toUpperCase(),
+        description: params.description,
+        packageName: params.package_name.toUpperCase(),
+        language: lang,
+        masterLanguage: lang,
+        messages: [],
+    });
+    return connection.makeAdtRequest({
+        url: BASE,
+        method: 'POST',
+        timeout: (0, timeouts_1.getTimeout)('default'),
+        data: xmlBody,
+        headers: {
+            'Content-Type': 'application/xml',
+        },
+    });
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Message class delete operations.
+ *
+ * Uses the stateless ADT deletion service (`/sap/bc/adt/deletion/check` +
+ * `/sap/bc/adt/deletion/delete`) — the same mechanism Eclipse ADT and the other
+ * object types (domain, serviceDefinition, …) use. A direct
+ * `DELETE /messageclass/{name}?lockHandle=` leaves a lingering message-editing
+ * enqueue ("User is currently editing …") that blocks a same-name re-create, so
+ * it is NOT used here.
+ */
+import type { IAbapConnection, IAdtResponse } from '@mcp-abap-adt/interfaces';
+/**
+ * Low-level: check whether the message class can be deleted.
+ * POST /sap/bc/adt/deletion/check
+ */
+export declare function checkDeletion(connection: IAbapConnection, name: string): Promise<IAdtResponse>;
+/**
+ * Low-level: delete the message class via the deletion service.
+ * POST /sap/bc/adt/deletion/delete (stateless — no lock handle).
+ *
+ * corrNr / transport_request is intentionally omitted — local/no-transport path
+ * only, wired for transportable packages in the corrNr task.
+ */
+export declare function deleteMessageClass(connection: IAbapConnection, name: string): Promise<IAdtResponse>;
+//# sourceMappingURL=delete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/core/messageClass/delete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAe9E;;;GAGG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,YAAY,CAAC,CAkBvB;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,YAAY,CAAC,CAoBvB"}

package/dist/core/messageClass/delete.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Message class delete operations.
+ *
+ * Uses the stateless ADT deletion service (`/sap/bc/adt/deletion/check` +
+ * `/sap/bc/adt/deletion/delete`) — the same mechanism Eclipse ADT and the other
+ * object types (domain, serviceDefinition, …) use. A direct
+ * `DELETE /messageclass/{name}?lockHandle=` leaves a lingering message-editing
+ * enqueue ("User is currently editing …") that blocks a same-name re-create, so
+ * it is NOT used here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDeletion = checkDeletion;
+exports.deleteMessageClass = deleteMessageClass;
+const contentTypes_1 = require("../../constants/contentTypes");
+const internalUtils_1 = require("../../utils/internalUtils");
+const timeouts_1 = require("../../utils/timeouts");
+const BASE = '/sap/bc/adt/messageclass';
+const objectUri = (name) => `${BASE}/${(0, internalUtils_1.encodeSapObjectName)(name.toLowerCase())}`;
+/**
+ * Low-level: check whether the message class can be deleted.
+ * POST /sap/bc/adt/deletion/check
+ */
+async function checkDeletion(connection, name) {
+    if (!name)
+        throw new Error('name is required');
+    const xmlPayload = `<?xml version="1.0" encoding="UTF-8"?>
+<del:checkRequest xmlns:del="http://www.sap.com/adt/deletion" xmlns:adtcore="http://www.sap.com/adt/core">
+  <del:object adtcore:uri="${objectUri(name)}"/>
+</del:checkRequest>`;
+    return connection.makeAdtRequest({
+        url: '/sap/bc/adt/deletion/check',
+        method: 'POST',
+        timeout: (0, timeouts_1.getTimeout)('default'),
+        data: xmlPayload,
+        headers: {
+            Accept: contentTypes_1.ACCEPT_DELETION_CHECK,
+            'Content-Type': contentTypes_1.CT_DELETION_CHECK,
+        },
+    });
+}
+/**
+ * Low-level: delete the message class via the deletion service.
+ * POST /sap/bc/adt/deletion/delete (stateless — no lock handle).
+ *
+ * corrNr / transport_request is intentionally omitted — local/no-transport path
+ * only, wired for transportable packages in the corrNr task.
+ */
+async function deleteMessageClass(connection, name) {
+    if (!name)
+        throw new Error('name is required');
+    const xmlPayload = `<?xml version="1.0" encoding="UTF-8"?>
+<del:deletionRequest xmlns:del="http://www.sap.com/adt/deletion" xmlns:adtcore="http://www.sap.com/adt/core">
+  <del:object adtcore:uri="${objectUri(name)}">
+    <del:transportNumber/>
+  </del:object>
+</del:deletionRequest>`;
+    return connection.makeAdtRequest({
+        url: '/sap/bc/adt/deletion/delete',
+        method: 'POST',
+        timeout: (0, timeouts_1.getTimeout)('default'),
+        data: xmlPayload,
+        headers: {
+            Accept: contentTypes_1.ACCEPT_DELETION,
+            'Content-Type': contentTypes_1.CT_DELETION,
+        },
+    });
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Message class operations - public exports
+ */
+import type { IAdtObject } from '@mcp-abap-adt/interfaces';
+import type { IMessageClassConfig, IMessageClassMessageConfig, IMessageClassMessageState, IMessageClassState } from './types';
+export { AdtMessageClass } from './AdtMessageClass';
+export { AdtMessageClassMessage } from './AdtMessageClassMessage';
+export * from './types';
+export type { IParsedMessage, IParsedMessageClass } from './xml';
+export { buildMessageClassXml, parseMessageClass } from './xml';
+export type AdtMessageClassType = IAdtObject<IMessageClassConfig, IMessageClassState>;
+export type AdtMessageClassMessageType = IAdtObject<IMessageClassMessageConfig, IMessageClassMessageState>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/messageClass/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EACV,mBAAmB,EACnB,0BAA0B,EAC1B,yBAAyB,EACzB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,cAAc,SAAS,CAAC;AACxB,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAGhE,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAC1C,mBAAmB,EACnB,kBAAkB,CACnB,CAAC;AAGF,MAAM,MAAM,0BAA0B,GAAG,UAAU,CACjD,0BAA0B,EAC1B,yBAAyB,CAC1B,CAAC"}

package/dist/core/messageClass/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Message class operations - public 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.parseMessageClass = exports.buildMessageClassXml = exports.AdtMessageClassMessage = exports.AdtMessageClass = void 0;
+var AdtMessageClass_1 = require("./AdtMessageClass");
+Object.defineProperty(exports, "AdtMessageClass", { enumerable: true, get: function () { return AdtMessageClass_1.AdtMessageClass; } });
+var AdtMessageClassMessage_1 = require("./AdtMessageClassMessage");
+Object.defineProperty(exports, "AdtMessageClassMessage", { enumerable: true, get: function () { return AdtMessageClassMessage_1.AdtMessageClassMessage; } });
+__exportStar(require("./types"), exports);
+var xml_1 = require("./xml");
+Object.defineProperty(exports, "buildMessageClassXml", { enumerable: true, get: function () { return xml_1.buildMessageClassXml; } });
+Object.defineProperty(exports, "parseMessageClass", { enumerable: true, get: function () { return xml_1.parseMessageClass; } });

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

@@ -0,0 +1,26 @@
+/**
+ * Message class lock operations
+ */
+import type { IAbapConnection } from '@mcp-abap-adt/interfaces';
+/**
+ * Lock a message class for modification.
+ * Returns the lock handle that must be used in subsequent update/delete requests.
+ *
+ * NOTE: Caller must enable stateful session via connection.setSessionType('stateful') first.
+ */
+export declare function lockMessageClass(connection: IAbapConnection, name: string): Promise<string>;
+/**
+ * Lock an individual message for modification.
+ * Returns the message lock handle (MH) used in PUT XML as mc:lockhandle.
+ *
+ * NOTE: Caller must enable stateful session via connection.setSessionType('stateful') first.
+ */
+export declare function lockMessage(connection: IAbapConnection, name: string, no: string): Promise<string>;
+/**
+ * Lock a message class in the context of a specific message save.
+ * Returns the class lock handle (CH) used in PUT ?lockHandle= parameter.
+ *
+ * NOTE: Caller must enable stateful session via connection.setSessionType('stateful') first.
+ */
+export declare function lockClassForMessage(connection: IAbapConnection, name: string, no: string): Promise<string>;
+//# sourceMappingURL=lock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../src/core/messageClass/lock.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AA0BhE;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,MAAM,CAAC,CAajB"}

package/dist/core/messageClass/lock.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Message class lock operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockMessageClass = lockMessageClass;
+exports.lockMessage = lockMessage;
+exports.lockClassForMessage = lockClassForMessage;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const contentTypes_1 = require("../../constants/contentTypes");
+const internalUtils_1 = require("../../utils/internalUtils");
+const timeouts_1 = require("../../utils/timeouts");
+const BASE = '/sap/bc/adt/messageclass';
+// Accept header for individual message lock (StatusMessage response type)
+const ACCEPT_LOCK_MSG = 'application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.StatusMessage';
+/** Parse LOCK_HANDLE from the asx:abap lock response XML. Throws with errLabel if absent. */
+function parseLockHandle(data, errLabel) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+    });
+    const result = parser.parse(data);
+    const lockHandle = result['asx:abap']?.['asx:values']?.DATA?.LOCK_HANDLE;
+    if (!lockHandle) {
+        throw new Error(`Failed to extract lock handle from ${errLabel}`);
+    }
+    return lockHandle;
+}
+/**
+ * Lock a message class for modification.
+ * Returns the lock handle that must be used in subsequent update/delete requests.
+ *
+ * NOTE: Caller must enable stateful session via connection.setSessionType('stateful') first.
+ */
+async function lockMessageClass(connection, name) {
+    const encoded = (0, internalUtils_1.encodeSapObjectName)(name.toLowerCase());
+    const url = `${BASE}/${encoded}?_action=LOCK&accessMode=MODIFY`;
+    const response = await connection.makeAdtRequest({
+        url,
+        method: 'POST',
+        timeout: (0, timeouts_1.getTimeout)('default'),
+        data: null,
+        headers: { Accept: contentTypes_1.ACCEPT_LOCK },
+    });
+    return parseLockHandle(response.data, 'message class lock response');
+}
+/**
+ * Lock an individual message for modification.
+ * Returns the message lock handle (MH) used in PUT XML as mc:lockhandle.
+ *
+ * NOTE: Caller must enable stateful session via connection.setSessionType('stateful') first.
+ */
+async function lockMessage(connection, name, no) {
+    const encoded = (0, internalUtils_1.encodeSapObjectName)(name.toLowerCase());
+    const url = `${BASE}/${encoded}/messages/${encodeURIComponent(no)}?_action=LOCK_MSG&accessMode=MODIFY`;
+    const response = await connection.makeAdtRequest({
+        url,
+        method: 'POST',
+        timeout: (0, timeouts_1.getTimeout)('default'),
+        data: null,
+        headers: { Accept: ACCEPT_LOCK_MSG },
+    });
+    return parseLockHandle(response.data, 'message lock response');
+}
+/**
+ * Lock a message class in the context of a specific message save.
+ * Returns the class lock handle (CH) used in PUT ?lockHandle= parameter.
+ *
+ * NOTE: Caller must enable stateful session via connection.setSessionType('stateful') first.
+ */
+async function lockClassForMessage(connection, name, no) {
+    const encoded = (0, internalUtils_1.encodeSapObjectName)(name.toLowerCase());
+    const url = `${BASE}/${encoded}?_action=LOCK&accessMode=MODIFY&msgNo=${encodeURIComponent(no)}&onSave=X`;
+    const response = await connection.makeAdtRequest({
+        url,
+        method: 'POST',
+        timeout: (0, timeouts_1.getTimeout)('default'),
+        data: null,
+        headers: { Accept: contentTypes_1.ACCEPT_LOCK },
+    });
+    return parseLockHandle(response.data, 'class-for-message lock response');
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Message class read operations
+ */
+import type { IAbapConnection, IAdtResponse } from '@mcp-abap-adt/interfaces';
+/**
+ * Read message class metadata and messages.
+ * GET /sap/bc/adt/messageclass/{name}
+ */
+export declare function getMessageClassSource(connection: IAbapConnection, name: string): Promise<IAdtResponse>;
+//# sourceMappingURL=read.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../src/core/messageClass/read.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAU9E;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,YAAY,CAAC,CAQvB"}