@mcp-abap-adt/adt-clients 0.1.0

package/dist/core/domain/DomainBuilder.js

@@ -0,0 +1,430 @@
+"use strict";
+/**
+ * DomainBuilder - Fluent API for domain operations with Promise chaining
+ *
+ * Supports:
+ * - Method chaining: builder.create().then(b => b.lock()).then(b => b.update())...
+ * - 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 DomainBuilder(connection, logger, {
+ *   domainName: 'Z_TEST_DOMAIN',
+ *   packageName: 'ZOK_TEST_PKG_01'
+ * });
+ *
+ * await builder
+ *   .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);
+ *   })
+ *   .finally(() => {
+ *     // Cleanup - always executes
+ *   });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainBuilder = void 0;
+const sessionUtils_1 = require("../../utils/sessionUtils");
+const create_1 = require("./create");
+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");
+const validation_1 = require("../shared/validation");
+const systemInfo_1 = require("../shared/systemInfo");
+const read_1 = require("./read");
+class DomainBuilder {
+    connection;
+    logger;
+    config;
+    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(domainName) {
+        this.config.domainName = domainName;
+        this.logger.debug?.('Domain name set:', domainName);
+        return this;
+    }
+    setDescription(description) {
+        this.config.description = description;
+        return this;
+    }
+    setDatatype(datatype) {
+        this.config.datatype = datatype;
+        return this;
+    }
+    setLength(length) {
+        this.config.length = length;
+        return this;
+    }
+    setDecimals(decimals) {
+        this.config.decimals = decimals;
+        return this;
+    }
+    setConversionExit(conversion_exit) {
+        this.config.conversion_exit = conversion_exit;
+        return this;
+    }
+    setLowercase(lowercase) {
+        this.config.lowercase = lowercase;
+        return this;
+    }
+    setSignExists(sign_exists) {
+        this.config.sign_exists = sign_exists;
+        return this;
+    }
+    setValueTable(value_table) {
+        this.config.value_table = value_table;
+        return this;
+    }
+    setFixedValues(fixed_values) {
+        this.config.fixed_values = fixed_values;
+        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 domain name:', this.config.domainName);
+            const result = await (0, validation_1.validateObjectName)(this.connection, 'DOMA/DD', this.config.domainName, this.config.packageName ? { packagename: this.config.packageName } : undefined);
+            this.state.validationResult = result;
+            if (!result.valid) {
+                throw new Error(`Domain name validation failed: ${result.message || 'Invalid domain name'}`);
+            }
+            this.logger.info?.('Domain name validation successful');
+            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 empty domain:', this.config.domainName);
+            // Get masterSystem and responsible (only for cloud systems)
+            const systemInfo = await (0, systemInfo_1.getSystemInformation)(this.connection);
+            const masterSystem = systemInfo?.systemID;
+            const username = systemInfo?.userName || process.env.SAP_USER || process.env.SAP_USERNAME || 'MPCUSER';
+            const params = {
+                domain_name: this.config.domainName,
+                package_name: this.config.packageName,
+                transport_request: this.config.transportRequest,
+                description: this.config.description,
+                datatype: this.config.datatype,
+                length: this.config.length,
+                decimals: this.config.decimals,
+                conversion_exit: this.config.conversion_exit,
+                lowercase: this.config.lowercase,
+                sign_exists: this.config.sign_exists,
+                value_table: this.config.value_table,
+                fixed_values: this.config.fixed_values
+            };
+            // Create empty domain only (initial POST to register the name)
+            const result = await (0, create_1.createEmptyDomain)(this.connection, params, this.sessionId, username, masterSystem);
+            this.state.createResult = result;
+            this.logger.info?.('Empty domain 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 lock() {
+        try {
+            this.logger.info?.('Locking domain:', this.config.domainName);
+            const lockHandle = await (0, lock_1.lockDomain)(this.connection, this.config.domainName, 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?.('Domain 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() {
+        try {
+            if (!this.lockHandle) {
+                throw new Error('Domain must be locked before update. Call lock() first.');
+            }
+            if (!this.config.packageName) {
+                throw new Error('Package name is required');
+            }
+            // Get masterSystem and responsible (only for cloud systems)
+            const systemInfo = await (0, systemInfo_1.getSystemInformation)(this.connection);
+            const masterSystem = systemInfo?.systemID;
+            const username = systemInfo?.userName || process.env.SAP_USER || process.env.SAP_USERNAME || 'MPCUSER';
+            // Check if this is a CREATE workflow (createResult exists) or UPDATE workflow
+            const isCreateWorkflow = !!this.state.createResult;
+            if (isCreateWorkflow) {
+                // For CREATE workflow: use lockAndCreateDomain to fill empty domain with data
+                this.logger.info?.('Filling domain with data (CREATE workflow):', this.config.domainName);
+                const createParams = {
+                    domain_name: this.config.domainName,
+                    package_name: this.config.packageName,
+                    transport_request: this.config.transportRequest,
+                    description: this.config.description,
+                    datatype: this.config.datatype,
+                    length: this.config.length,
+                    decimals: this.config.decimals,
+                    conversion_exit: this.config.conversion_exit,
+                    lowercase: this.config.lowercase,
+                    sign_exists: this.config.sign_exists,
+                    value_table: this.config.value_table,
+                    fixed_values: this.config.fixed_values
+                };
+                const result = await (0, create_1.lockAndCreateDomain)(this.connection, createParams, this.lockHandle, this.sessionId, username, masterSystem);
+                this.state.updateResult = result;
+                this.logger.info?.('Domain filled with data successfully:', result.status);
+            }
+            else {
+                // For UPDATE workflow: use updateDomain to update existing domain
+                this.logger.info?.('Updating domain (UPDATE workflow):', this.config.domainName);
+                const updateParams = {
+                    domain_name: this.config.domainName,
+                    package_name: this.config.packageName,
+                    transport_request: this.config.transportRequest,
+                    description: this.config.description,
+                    datatype: this.config.datatype,
+                    length: this.config.length,
+                    decimals: this.config.decimals,
+                    conversion_exit: this.config.conversion_exit,
+                    lowercase: this.config.lowercase,
+                    sign_exists: this.config.sign_exists,
+                    value_table: this.config.value_table,
+                    fixed_values: this.config.fixed_values,
+                    activate: false // Don't activate in low-level function
+                };
+                const result = await (0, update_1.updateDomain)(this.connection, updateParams);
+                this.state.updateResult = result;
+                this.logger.info?.('Domain 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 domain:', this.config.domainName, 'version:', version);
+            const result = await (0, check_1.checkDomainSyntax)(this.connection, this.config.domainName, version, this.sessionId);
+            this.state.checkResult = result;
+            this.logger.info?.('Domain 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('Domain is not locked. Call lock() first.');
+            }
+            this.logger.info?.('Unlocking domain:', this.config.domainName);
+            const result = await (0, unlock_1.unlockDomain)(this.connection, this.config.domainName, this.lockHandle, this.sessionId);
+            this.state.unlockResult = result;
+            this.lockHandle = undefined;
+            this.state.lockHandle = undefined;
+            this.logger.info?.('Domain unlocked successfully');
+            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 domain:', this.config.domainName);
+            const result = await (0, activation_1.activateDomain)(this.connection, this.config.domainName, this.sessionId);
+            this.state.activateResult = result;
+            this.logger.info?.('Domain 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 read() {
+        try {
+            this.logger.info?.('Reading domain:', this.config.domainName);
+            const result = await (0, read_1.getDomain)(this.connection, this.config.domainName);
+            this.state.readResult = result;
+            this.logger.info?.('Domain read successfully:', result.status);
+            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:', error);
+            throw error; // Interrupts chain
+        }
+    }
+    async readTransport() {
+        try {
+            this.logger.info?.('Reading transport request for domain:', this.config.domainName);
+            const result = await (0, read_1.getDomainTransport)(this.connection, this.config.domainName);
+            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 forceUnlock() {
+        if (!this.lockHandle) {
+            return;
+        }
+        try {
+            await (0, unlock_1.unlockDomain)(this.connection, this.config.domainName, this.lockHandle, this.sessionId);
+            this.logger.info?.('Force unlock successful for', this.config.domainName);
+        }
+        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 };
+    }
+    getDomainName() {
+        return this.config.domainName;
+    }
+    getLockHandle() {
+        return this.lockHandle;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getCreateResult() {
+        return this.state.createResult;
+    }
+    getUpdateResult() {
+        return this.state.updateResult;
+    }
+    getCheckResult() {
+        return this.state.checkResult;
+    }
+    getUnlockResult() {
+        return this.state.unlockResult;
+    }
+    getActivateResult() {
+        return this.state.activateResult;
+    }
+    getReadResult() {
+        return this.state.readResult;
+    }
+    getTransportResult() {
+        return this.state.transportResult;
+    }
+    getErrors() {
+        return [...this.state.errors];
+    }
+    // Helper method to get all results
+    getResults() {
+        return {
+            create: this.state.createResult,
+            update: this.state.updateResult,
+            check: this.state.checkResult,
+            unlock: this.state.unlockResult,
+            activate: this.state.activateResult,
+            lockHandle: this.lockHandle,
+            errors: [...this.state.errors]
+        };
+    }
+}
+exports.DomainBuilder = DomainBuilder;

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

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

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

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

package/dist/core/domain/activation.js

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

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

@@ -0,0 +1,16 @@
+/**
+ * Domain check operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Check domain syntax
+ *
+ * @param connection - SAP connection
+ * @param domainName - Domain name
+ * @param version - 'active' (activated version) or 'inactive' (saved but not activated)
+ * @param sessionId - Session ID (required for domain operations)
+ * @returns Check result with errors/warnings
+ */
+export declare function checkDomainSyntax(connection: AbapConnection, domainName: string, version: 'active' | 'inactive', sessionId: string): Promise<AxiosResponse>;
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/core/domain/check.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,cAAc,EAC1B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CAsBxB"}

package/dist/core/domain/check.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Domain check operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDomainSyntax = checkDomainSyntax;
+const checkRun_1 = require("../shared/checkRun");
+/**
+ * Check domain syntax
+ *
+ * @param connection - SAP connection
+ * @param domainName - Domain name
+ * @param version - 'active' (activated version) or 'inactive' (saved but not activated)
+ * @param sessionId - Session ID (required for domain operations)
+ * @returns Check result with errors/warnings
+ */
+async function checkDomainSyntax(connection, domainName, version, sessionId) {
+    const response = await (0, checkRun_1.runCheckRun)(connection, 'domain', domainName, version, 'abapCheckRun', sessionId);
+    const checkResult = (0, checkRun_1.parseCheckRunResponse)(response);
+    if (!checkResult.success && checkResult.has_errors) {
+        // "has been checked" is a non-critical warning - domain was already checked
+        const errorMessage = checkResult.message || '';
+        // Check both message and errors array for "has been checked" message
+        const hasCheckedMessage = errorMessage.toLowerCase().includes('has been checked') ||
+            checkResult.errors.some((err) => (err.text || '').toLowerCase().includes('has been checked'));
+        if (hasCheckedMessage) {
+            // This is expected behavior - domain was already checked, return response anyway
+            if (process.env.DEBUG_TESTS === 'true') {
+                console.warn(`Check warning for domain ${domainName}: ${errorMessage} (domain was already checked)`);
+            }
+            return response; // Return response anyway
+        }
+        throw new Error(`Domain check failed: ${checkResult.message}`);
+    }
+    return response;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Domain create operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+import { CreateDomainParams } from './types';
+/**
+ * Create empty domain (initial POST to register the name)
+ */
+export declare function createEmptyDomain(connection: AbapConnection, args: CreateDomainParams, sessionId: string, username: string, masterSystem?: string): Promise<AxiosResponse>;
+/**
+ * Create domain with lock handle
+ * Build XML from scratch using parameters
+ */
+export declare function lockAndCreateDomain(connection: AbapConnection, args: CreateDomainParams, lockHandle: string, sessionId: string, username: string, masterSystem?: string): Promise<AxiosResponse>;
+/**
+ * Create ABAP domain
+ * Full workflow: create empty -> lock -> create with data -> check -> unlock -> activate
+ */
+export declare function createDomain(connection: AbapConnection, params: CreateDomainParams): Promise<AxiosResponse>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/core/domain/create.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAStC,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,cAAc,EAC1B,IAAI,EAAE,kBAAkB,EACxB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC,CAuBxB;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,cAAc,EAC1B,IAAI,EAAE,kBAAkB,EACxB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC,CAyDxB;AA4BD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,aAAa,CAAC,CAoExB"}