@mcp-abap-adt/adt-clients 0.1.0

package/dist/core/class/ClassBuilder.js

@@ -0,0 +1,400 @@
+"use strict";
+/**
+ * ClassBuilder - Fluent API for class operations with Promise chaining
+ *
+ * Supports:
+ * - Method chaining: builder.validate().then(b => b.create()).then(b => b.lock())...
+ * - Error handling: .catch() for error callbacks
+ * - Cleanup: .finally() for guaranteed execution
+ * - Result storage: all results stored in logger/state
+ * - Chain interruption: chain stops on first error (standard Promise behavior)
+ *
+ * @example
+ * ```typescript
+ * const builder = new ClassBuilder(connection, logger, {
+ *   className: 'ZCL_TEST',
+ *   packageName: 'ZOK_TEST_PKG_01'
+ * })
+ *   .setCode('CLASS ZCL_TEST DEFINITION...');
+ *
+ * await builder
+ *   .validate()
+ *   .then(b => b.create())
+ *   .then(b => b.lock())
+ *   .then(b => b.update())
+ *   .then(b => b.check())
+ *   .then(b => b.unlock())
+ *   .then(b => b.activate())
+ *   .catch(error => {
+ *     logger.error('Operation failed:', error);
+ *     // Handle error
+ *   })
+ *   .finally(() => {
+ *     // Cleanup - always executes
+ *   });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassBuilder = void 0;
+const sessionUtils_1 = require("../../utils/sessionUtils");
+const validation_1 = require("./validation");
+const create_1 = require("./create");
+const read_1 = require("./read");
+const lock_1 = require("./lock");
+const update_1 = require("./update");
+const check_1 = require("./check");
+const unlock_1 = require("./unlock");
+const activation_1 = require("./activation");
+class ClassBuilder {
+    connection;
+    logger;
+    config;
+    sourceCode;
+    lockHandle;
+    sessionId;
+    state;
+    constructor(connection, logger, config) {
+        this.connection = connection;
+        this.logger = logger;
+        this.config = { ...config };
+        this.sessionId = config.sessionId || (0, sessionUtils_1.generateSessionId)();
+        this.state = {
+            errors: []
+        };
+    }
+    // Builder methods - return this for chaining
+    setPackage(packageName) {
+        this.config.packageName = packageName;
+        this.logger.debug?.('Package set:', packageName);
+        return this;
+    }
+    setRequest(transportRequest) {
+        this.config.transportRequest = transportRequest;
+        this.logger.debug?.('Transport request set:', transportRequest);
+        return this;
+    }
+    setName(className) {
+        this.config.className = className;
+        this.logger.debug?.('Class name set:', className);
+        return this;
+    }
+    setCode(sourceCode) {
+        this.sourceCode = sourceCode;
+        this.logger.debug?.('Source code set, length:', sourceCode.length);
+        return this;
+    }
+    setDescription(description) {
+        this.config.description = description;
+        return this;
+    }
+    setSuperclass(superclass) {
+        this.config.superclass = superclass;
+        return this;
+    }
+    setFinal(final) {
+        this.config.final = final;
+        return this;
+    }
+    setAbstract(abstract) {
+        this.config.abstract = abstract;
+        return this;
+    }
+    setCreateProtected(createProtected) {
+        this.config.createProtected = createProtected;
+        return this;
+    }
+    // Operation methods - return Promise<this> for Promise chaining
+    // Chain is interrupted on error (standard Promise behavior)
+    async validate() {
+        try {
+            this.logger.info?.('Validating class:', this.config.className);
+            const result = await (0, validation_1.validateClassName)(this.connection, this.config.className, this.config.packageName, this.config.description, this.config.superclass);
+            this.state.validationResult = result;
+            this.logger.info?.('Validation successful:', result.valid);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'validate',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Validation failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async create() {
+        try {
+            if (!this.config.packageName) {
+                throw new Error('Package name is required');
+            }
+            this.logger.info?.('Creating class:', this.config.className);
+            const result = await (0, create_1.createClass)(this.connection, {
+                class_name: this.config.className,
+                package_name: this.config.packageName,
+                transport_request: this.config.transportRequest,
+                description: this.config.description,
+                superclass: this.config.superclass,
+                final: this.config.final,
+                abstract: this.config.abstract,
+                create_protected: this.config.createProtected,
+                master_system: this.config.masterSystem,
+                responsible: this.config.responsible,
+            });
+            this.state.createResult = result;
+            this.logger.info?.('Class created successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'create',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Create failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async read(version = 'active') {
+        try {
+            this.logger.info?.('Reading class source:', this.config.className, 'version:', version);
+            const result = await (0, read_1.getClassSource)(this.connection, this.config.className, version);
+            this.state.readResult = result;
+            this.logger.info?.('Class source read successfully:', result.status, 'bytes:', result.data?.length || 0);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'read',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Read failed:', {
+                className: this.config.className,
+                version,
+                status: error.response?.status,
+                statusText: error.response?.statusText,
+                data: error.response?.data,
+                message: error.message
+            });
+            throw error; // Interrupts chain
+        }
+    }
+    async readMetadata() {
+        try {
+            this.logger.info?.('Reading class metadata:', this.config.className);
+            const result = await (0, read_1.getClassMetadata)(this.connection, this.config.className);
+            this.state.metadataResult = result;
+            this.logger.info?.('Class metadata read successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'readMetadata',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Read metadata failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async readTransport() {
+        try {
+            this.logger.info?.('Reading transport request for class:', this.config.className);
+            const result = await (0, read_1.getClassTransport)(this.connection, this.config.className);
+            this.state.transportResult = result;
+            this.logger.info?.('Transport request read successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'readTransport',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Read transport failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async lock() {
+        try {
+            this.logger.info?.('Locking class:', this.config.className);
+            const lockHandle = await (0, lock_1.lockClass)(this.connection, this.config.className, this.sessionId);
+            this.lockHandle = lockHandle;
+            this.state.lockHandle = lockHandle;
+            // Register lock in persistent storage if callback provided
+            if (this.config.onLock) {
+                this.config.onLock(lockHandle, this.sessionId);
+            }
+            this.logger.info?.('Class locked, handle:', lockHandle.substring(0, 10) + '...');
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'lock',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Lock failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async update(sourceCode) {
+        try {
+            if (!this.lockHandle) {
+                throw new Error('Class must be locked before update. Call lock() first.');
+            }
+            const code = sourceCode || this.sourceCode;
+            if (!code) {
+                throw new Error('Source code is required. Use setCode() or pass as parameter.');
+            }
+            this.logger.info?.('Updating class source:', this.config.className);
+            const result = await (0, update_1.updateClass)(this.connection, this.config.className, code, this.lockHandle, this.sessionId, this.config.transportRequest);
+            this.state.updateResult = result;
+            this.logger.info?.('Class updated successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'update',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Update failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async check(version = 'inactive') {
+        try {
+            this.logger.info?.('Checking class:', this.config.className, 'version:', version);
+            const result = await (0, check_1.checkClass)(this.connection, this.config.className, version, this.sourceCode, this.sessionId);
+            this.state.checkResult = result;
+            this.logger.info?.('Class check successful:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'check',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Check failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async unlock() {
+        try {
+            if (!this.lockHandle) {
+                throw new Error('Class is not locked. Call lock() first.');
+            }
+            this.logger.info?.('Unlocking class:', this.config.className);
+            const result = await (0, unlock_1.unlockClass)(this.connection, this.config.className, this.lockHandle, this.sessionId);
+            this.state.unlockResult = result;
+            this.lockHandle = undefined;
+            this.logger.info?.('Class unlocked successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'unlock',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Unlock failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async activate() {
+        try {
+            this.logger.info?.('Activating class:', this.config.className);
+            const result = await (0, activation_1.activateClass)(this.connection, this.config.className, this.sessionId);
+            this.state.activateResult = result;
+            this.logger.info?.('Class activated successfully:', result.status);
+            return this;
+        }
+        catch (error) {
+            this.state.errors.push({
+                method: 'activate',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: new Date()
+            });
+            this.logger.error?.('Activate failed:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async forceUnlock() {
+        if (!this.lockHandle) {
+            return;
+        }
+        try {
+            await (0, unlock_1.unlockClass)(this.connection, this.config.className, this.lockHandle, this.sessionId);
+            this.logger.info?.('Force unlock successful for', this.config.className);
+        }
+        catch (error) {
+            this.logger.warn?.('Force unlock failed:', error);
+        }
+        finally {
+            this.lockHandle = undefined;
+            this.state.lockHandle = undefined;
+        }
+    }
+    // Getters for accessing results
+    getState() {
+        return { ...this.state };
+    }
+    getValidationResult() {
+        return this.state.validationResult;
+    }
+    getCreateResult() {
+        return this.state.createResult;
+    }
+    getReadResult() {
+        return this.state.readResult;
+    }
+    getMetadataResult() {
+        return this.state.metadataResult;
+    }
+    getTransportResult() {
+        return this.state.transportResult;
+    }
+    getLockHandle() {
+        return this.lockHandle;
+    }
+    getUpdateResult() {
+        return this.state.updateResult;
+    }
+    getCheckResult() {
+        return this.state.checkResult;
+    }
+    getUnlockResult() {
+        return this.state.unlockResult;
+    }
+    getActivateResult() {
+        return this.state.activateResult;
+    }
+    getErrors() {
+        return [...this.state.errors];
+    }
+    getClassName() {
+        return this.config.className;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    // Helper method to get all results
+    getResults() {
+        return {
+            validation: this.state.validationResult,
+            create: this.state.createResult,
+            read: this.state.readResult,
+            metadata: this.state.metadataResult,
+            update: this.state.updateResult,
+            check: this.state.checkResult,
+            unlock: this.state.unlockResult,
+            activate: this.state.activateResult,
+            lockHandle: this.lockHandle,
+            errors: [...this.state.errors]
+        };
+    }
+}
+exports.ClassBuilder = ClassBuilder;

package/dist/core/class/activation.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Class activation operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Activate class
+ * Makes class active and usable in SAP system
+ */
+export declare function activateClass(connection: AbapConnection, className: string, sessionId: string): Promise<AxiosResponse>;
+//# sourceMappingURL=activation.d.ts.map

package/dist/core/class/activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activation.d.ts","sourceRoot":"","sources":["../../../src/core/class/activation.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,aAAa,CACjC,UAAU,EAAE,cAAc,EAC1B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CAGxB"}

package/dist/core/class/activation.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Class activation operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateClass = activateClass;
+const internalUtils_1 = require("../../utils/internalUtils");
+const activationUtils_1 = require("../../utils/activationUtils");
+/**
+ * Activate class
+ * Makes class active and usable in SAP system
+ */
+async function activateClass(connection, className, sessionId) {
+    const objectUri = `/sap/bc/adt/oo/classes/${(0, internalUtils_1.encodeSapObjectName)(className).toLowerCase()}`;
+    return await (0, activationUtils_1.activateObjectInSession)(connection, objectUri, className, sessionId, true);
+}

package/dist/core/class/check.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Class check operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Check class code (syntax, compilation, rules)
+ *
+ * CheckRun validates everything: syntax, compilation errors, warnings, code quality rules.
+ *
+ * Can check:
+ * - Existing active class: provide className, version='active', omit sourceCode
+ * - Existing inactive class: provide className, version='inactive', omit sourceCode
+ * - Hypothetical code: provide className, sourceCode, version (object doesn't need to exist)
+ *
+ * @param connection - SAP connection
+ * @param className - Class name
+ * @param version - 'active' (activated version) or 'inactive' (saved but not activated)
+ * @param sourceCode - Optional: source code to validate. If provided, validates hypothetical code without creating object
+ * @param sessionId - Optional session ID
+ * @returns Check result with errors/warnings
+ */
+export declare function checkClass(connection: AbapConnection, className: string, version: 'active' | 'inactive', sourceCode?: string, sessionId?: string): Promise<AxiosResponse>;
+//# sourceMappingURL=check.d.ts.map

package/dist/core/class/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/core/class/check.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,UAAU,CAC9B,UAAU,EAAE,cAAc,EAC1B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,CAAC,CAoBxB"}

package/dist/core/class/check.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Class check operations
+ */
+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.checkClass = checkClass;
+/**
+ * Check class code (syntax, compilation, rules)
+ *
+ * CheckRun validates everything: syntax, compilation errors, warnings, code quality rules.
+ *
+ * Can check:
+ * - Existing active class: provide className, version='active', omit sourceCode
+ * - Existing inactive class: provide className, version='inactive', omit sourceCode
+ * - Hypothetical code: provide className, sourceCode, version (object doesn't need to exist)
+ *
+ * @param connection - SAP connection
+ * @param className - Class name
+ * @param version - 'active' (activated version) or 'inactive' (saved but not activated)
+ * @param sourceCode - Optional: source code to validate. If provided, validates hypothetical code without creating object
+ * @param sessionId - Optional session ID
+ * @returns Check result with errors/warnings
+ */
+async function checkClass(connection, className, version, sourceCode, sessionId) {
+    const { runCheckRun, runCheckRunWithSource, parseCheckRunResponse } = await Promise.resolve().then(() => __importStar(require('../shared/checkRun')));
+    let response;
+    if (sourceCode) {
+        // Validate hypothetical code (object doesn't need to exist)
+        response = await runCheckRunWithSource(connection, 'class', className, sourceCode, version, 'abapCheckRun', sessionId);
+    }
+    else {
+        // Validate existing object in SAP (reads from system)
+        response = await runCheckRun(connection, 'class', className, version, 'abapCheckRun', sessionId);
+    }
+    const checkResult = parseCheckRunResponse(response);
+    if (!checkResult.success || checkResult.has_errors) {
+        throw new Error(`Class check failed: ${checkResult.message}`);
+    }
+    return response;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Class create operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+export interface CreateClassParams {
+    class_name: string;
+    description?: string;
+    package_name: string;
+    transport_request?: string;
+    master_system?: string;
+    responsible?: string;
+    superclass?: string;
+    final?: boolean;
+    abstract?: boolean;
+    create_protected?: boolean;
+}
+/**
+ * Create ABAP class object (metadata only)
+ * Low-level function - only creates the class object with metadata
+ *
+ * To complete class creation workflow:
+ * 1. createClass() - create object
+ * 2. lockClass() - lock for modification
+ * 3. updateClass() - upload source code
+ * 4. unlockClass() - unlock
+ * 5. activateClass() - activate (optional)
+ */
+export declare function createClass(connection: AbapConnection, params: CreateClassParams): Promise<AxiosResponse>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/core/class/create.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAWtC,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,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,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAyFD;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,aAAa,CAAC,CA4BxB"}