@mcp-abap-adt/adt-clients 0.1.0

package/dist/core/domain/update.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Domain update operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDomain = updateDomain;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const internalUtils_1 = require("../../utils/internalUtils");
+const sessionUtils_1 = require("../../utils/sessionUtils");
+const systemInfo_1 = require("../shared/systemInfo");
+const lock_1 = require("./lock");
+const unlock_1 = require("./unlock");
+const activation_1 = require("./activation");
+const check_1 = require("./check");
+/**
+ * Update domain with new data
+ */
+async function updateDomainInternal(connection, args, lockHandle, sessionId, username, masterSystem) {
+    const domainNameEncoded = (0, internalUtils_1.encodeSapObjectName)(args.domain_name.toLowerCase());
+    const corrNrParam = args.transport_request ? `&corrNr=${args.transport_request}` : '';
+    const url = `/sap/bc/adt/ddic/domains/${domainNameEncoded}?lockHandle=${lockHandle}${corrNrParam}`;
+    const datatype = args.datatype || 'CHAR';
+    const length = args.length || 100;
+    const decimals = args.decimals || 0;
+    let fixValuesXml = '';
+    if (args.fixed_values && args.fixed_values.length > 0) {
+        const fixValueItems = args.fixed_values.map(fv => `      <doma:fixValue>\n        <doma:low>${fv.low}</doma:low>\n        <doma:text>${fv.text}</doma:text>\n      </doma:fixValue>`).join('\n');
+        fixValuesXml = `    <doma:fixValues>\n${fixValueItems}\n    </doma:fixValues>`;
+    }
+    else {
+        fixValuesXml = '    <doma:fixValues/>';
+    }
+    const masterSystemAttr = masterSystem ? ` adtcore:masterSystem="${masterSystem}"` : '';
+    const xmlBody = `<?xml version="1.0" encoding="UTF-8"?>
+<doma:domain xmlns:doma="http://www.sap.com/dictionary/domain"
+             xmlns:adtcore="http://www.sap.com/adt/core"
+             adtcore:description="${args.description || args.domain_name}"
+             adtcore:language="EN"
+             adtcore:name="${args.domain_name.toUpperCase()}"
+             adtcore:type="DOMA/DD"
+             adtcore:masterLanguage="EN"${masterSystemAttr}
+             adtcore:responsible="${username}">
+  <adtcore:packageRef adtcore:name="${args.package_name.toUpperCase()}"/>
+  <doma:content>
+    <doma:typeInformation>
+      <doma:datatype>${datatype}</doma:datatype>
+      <doma:length>${length}</doma:length>
+      <doma:decimals>${decimals}</doma:decimals>
+    </doma:typeInformation>
+    <doma:outputInformation>
+      <doma:length>${length}</doma:length>
+      <doma:conversionExit>${args.conversion_exit || ''}</doma:conversionExit>
+      <doma:signExists>${args.sign_exists || false}</doma:signExists>
+      <doma:lowercase>${args.lowercase || false}</doma:lowercase>
+    </doma:outputInformation>
+    <doma:valueInformation>
+      <doma:valueTableRef adtcore:name="${args.value_table || ''}"/>
+      <doma:appendExists>false</doma:appendExists>
+${fixValuesXml}
+    </doma:valueInformation>
+  </doma:content>
+</doma:domain>`;
+    const headers = {
+        'Accept': 'application/vnd.sap.adt.domains.v1+xml, application/vnd.sap.adt.domains.v2+xml',
+        'Content-Type': 'application/vnd.sap.adt.domains.v2+xml; charset=utf-8'
+    };
+    return (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'PUT', sessionId, xmlBody, headers);
+}
+/**
+ * Get domain to verify update
+ */
+async function getDomainForVerification(connection, domainName, sessionId) {
+    const domainNameEncoded = (0, internalUtils_1.encodeSapObjectName)(domainName.toLowerCase());
+    const url = `/sap/bc/adt/ddic/domains/${domainNameEncoded}?version=workingArea`;
+    const headers = {
+        'Accept': 'application/vnd.sap.adt.domains.v1+xml, application/vnd.sap.adt.domains.v2+xml'
+    };
+    const response = await (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'GET', sessionId, undefined, headers);
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+    });
+    const result = parser.parse(response.data);
+    return result['doma:domain'];
+}
+/**
+ * Update ABAP domain
+ * Full workflow: lock -> update -> check -> unlock -> activate
+ */
+async function updateDomain(connection, params) {
+    if (!params.domain_name) {
+        throw new Error('Domain name is required');
+    }
+    if (!params.package_name) {
+        throw new Error('Package name is required');
+    }
+    const sessionId = (0, sessionUtils_1.generateSessionId)();
+    // 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
+    const systemInfo = await (0, systemInfo_1.getSystemInformation)(connection);
+    const masterSystem = systemInfo?.systemID;
+    const username = systemInfo?.userName || process.env.SAP_USER || process.env.SAP_USERNAME || 'MPCUSER';
+    let lockHandle = '';
+    try {
+        lockHandle = await (0, lock_1.lockDomain)(connection, params.domain_name, sessionId);
+        await new Promise(resolve => setTimeout(resolve, 500));
+        await updateDomainInternal(connection, params, lockHandle, sessionId, username, masterSystem);
+        await (0, check_1.checkDomainSyntax)(connection, params.domain_name, 'inactive', sessionId);
+        await (0, unlock_1.unlockDomain)(connection, params.domain_name, lockHandle, sessionId);
+        const shouldActivate = params.activate !== false;
+        if (shouldActivate) {
+            await (0, activation_1.activateDomain)(connection, params.domain_name, sessionId);
+        }
+        const updatedDomain = await getDomainForVerification(connection, params.domain_name, sessionId);
+        return {
+            data: {
+                success: true,
+                domain_name: params.domain_name,
+                package: params.package_name,
+                transport_request: params.transport_request,
+                status: shouldActivate ? 'active' : 'inactive',
+                session_id: sessionId,
+                message: `Domain ${params.domain_name} updated${shouldActivate ? ' and activated' : ''} successfully`,
+                domain_details: updatedDomain
+            },
+            status: 200,
+            statusText: 'OK',
+            headers: {},
+            config: {}
+        };
+    }
+    catch (error) {
+        if (lockHandle) {
+            try {
+                await (0, unlock_1.unlockDomain)(connection, params.domain_name, lockHandle, sessionId);
+            }
+            catch (unlockError) {
+                // Ignore unlock errors
+            }
+        }
+        throw error;
+    }
+}

package/dist/core/functionGroup/FunctionGroupBuilder.d.ts

@@ -0,0 +1,91 @@
+/**
+ * FunctionGroupBuilder - Fluent API for function group 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)
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+import { ValidationResult } from '../shared/validation';
+export interface FunctionGroupBuilderLogger {
+    debug?: (message: string, ...args: any[]) => void;
+    info?: (message: string, ...args: any[]) => void;
+    warn?: (message: string, ...args: any[]) => void;
+    error?: (message: string, ...args: any[]) => void;
+}
+export interface FunctionGroupBuilderConfig {
+    functionGroupName: string;
+    packageName?: string;
+    transportRequest?: string;
+    description?: string;
+    sessionId?: string;
+    onLock?: (lockHandle: string, sessionId: string) => void;
+}
+export interface FunctionGroupBuilderState {
+    validationResult?: ValidationResult;
+    createResult?: AxiosResponse;
+    lockHandle?: string;
+    checkResult?: AxiosResponse;
+    unlockResult?: AxiosResponse;
+    activateResult?: AxiosResponse;
+    readResult?: AxiosResponse;
+    errors: Array<{
+        method: string;
+        error: Error;
+        timestamp: Date;
+    }>;
+}
+export declare class FunctionGroupBuilder {
+    private connection;
+    private logger;
+    private config;
+    private lockHandle?;
+    private sessionId;
+    private state;
+    constructor(connection: AbapConnection, logger: FunctionGroupBuilderLogger, config: FunctionGroupBuilderConfig);
+    setPackage(packageName: string): this;
+    setRequest(transportRequest: string): this;
+    setName(functionGroupName: string): this;
+    setDescription(description: string): this;
+    validate(): Promise<this>;
+    create(): Promise<this>;
+    lock(): Promise<this>;
+    check(version?: 'active' | 'inactive', sourceCode?: string): Promise<this>;
+    unlock(): Promise<this>;
+    activate(): Promise<this>;
+    read(): Promise<this>;
+    forceUnlock(): Promise<void>;
+    getState(): Readonly<FunctionGroupBuilderState>;
+    getFunctionGroupName(): string;
+    getLockHandle(): string | undefined;
+    getSessionId(): string;
+    getValidationResult(): ValidationResult | undefined;
+    getCreateResult(): AxiosResponse | undefined;
+    getCheckResult(): AxiosResponse | undefined;
+    getUnlockResult(): AxiosResponse | undefined;
+    getActivateResult(): AxiosResponse | undefined;
+    getReadResult(): AxiosResponse | undefined;
+    getErrors(): ReadonlyArray<{
+        method: string;
+        error: Error;
+        timestamp: Date;
+    }>;
+    getResults(): {
+        validation?: ValidationResult;
+        create?: AxiosResponse;
+        check?: AxiosResponse;
+        unlock?: AxiosResponse;
+        activate?: AxiosResponse;
+        lockHandle?: string;
+        errors: Array<{
+            method: string;
+            error: Error;
+            timestamp: Date;
+        }>;
+    };
+}
+//# sourceMappingURL=FunctionGroupBuilder.d.ts.map

package/dist/core/functionGroup/FunctionGroupBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionGroupBuilder.d.ts","sourceRoot":"","sources":["../../../src/core/functionGroup/FunctionGroupBuilder.ts"],"names":[],"mappings":"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"}

package/dist/core/functionGroup/FunctionGroupBuilder.js

@@ -0,0 +1,268 @@
+"use strict";
+/**
+ * FunctionGroupBuilder - Fluent API for function group 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)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionGroupBuilder = void 0;
+const sessionUtils_1 = require("../../utils/sessionUtils");
+const validation_1 = require("./validation");
+const create_1 = require("./create");
+const lock_1 = require("./lock");
+const unlock_1 = require("./unlock");
+const activation_1 = require("./activation");
+const check_1 = require("./check");
+const read_1 = require("./read");
+class FunctionGroupBuilder {
+    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(functionGroupName) {
+        this.config.functionGroupName = functionGroupName;
+        this.logger.debug?.('Function group name set:', functionGroupName);
+        return this;
+    }
+    setDescription(description) {
+        this.config.description = description;
+        return this;
+    }
+    // Operation methods - return Promise<this> for Promise chaining
+    async validate() {
+        try {
+            this.logger.info?.('Validating function group:', this.config.functionGroupName);
+            const result = await (0, validation_1.validateFunctionGroupName)(this.connection, this.config.functionGroupName, this.config.description);
+            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 function group:', this.config.functionGroupName);
+            const params = {
+                function_group_name: this.config.functionGroupName,
+                package_name: this.config.packageName,
+                transport_request: this.config.transportRequest,
+                description: this.config.description,
+                activate: false // Don't activate in low-level function
+            };
+            const result = await (0, create_1.createFunctionGroup)(this.connection, params);
+            this.state.createResult = result;
+            this.logger.info?.('Function group 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 function group:', this.config.functionGroupName);
+            const lockHandle = await (0, lock_1.lockFunctionGroup)(this.connection, this.config.functionGroupName, 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?.('Function group 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 check(version = 'inactive', sourceCode) {
+        try {
+            this.logger.info?.('Checking function group:', this.config.functionGroupName, 'version:', version);
+            const result = await (0, check_1.checkFunctionGroup)(this.connection, this.config.functionGroupName, version, sourceCode, this.sessionId);
+            this.state.checkResult = result;
+            this.logger.info?.('Function group 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('Function group is not locked. Call lock() first.');
+            }
+            this.logger.info?.('Unlocking function group:', this.config.functionGroupName);
+            const result = await (0, unlock_1.unlockFunctionGroup)(this.connection, this.config.functionGroupName, this.lockHandle, this.sessionId);
+            this.state.unlockResult = result;
+            this.lockHandle = undefined;
+            this.state.lockHandle = undefined;
+            this.logger.info?.('Function group 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 function group:', this.config.functionGroupName);
+            const result = await (0, activation_1.activateFunctionGroup)(this.connection, this.config.functionGroupName);
+            this.state.activateResult = result;
+            this.logger.info?.('Function group 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 function group:', this.config.functionGroupName);
+            const result = await (0, read_1.getFunctionGroup)(this.connection, this.config.functionGroupName);
+            this.state.readResult = result;
+            this.logger.info?.('Function group 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 forceUnlock() {
+        if (!this.lockHandle) {
+            return;
+        }
+        try {
+            await (0, unlock_1.unlockFunctionGroup)(this.connection, this.config.functionGroupName, this.lockHandle, this.sessionId);
+            this.logger.info?.('Force unlock successful for', this.config.functionGroupName);
+        }
+        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 };
+    }
+    getFunctionGroupName() {
+        return this.config.functionGroupName;
+    }
+    getLockHandle() {
+        return this.lockHandle;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getValidationResult() {
+        return this.state.validationResult;
+    }
+    getCreateResult() {
+        return this.state.createResult;
+    }
+    getCheckResult() {
+        return this.state.checkResult;
+    }
+    getUnlockResult() {
+        return this.state.unlockResult;
+    }
+    getActivateResult() {
+        return this.state.activateResult;
+    }
+    getReadResult() {
+        return this.state.readResult;
+    }
+    getErrors() {
+        return [...this.state.errors];
+    }
+    // Helper method to get all results
+    getResults() {
+        return {
+            validation: this.state.validationResult,
+            create: this.state.createResult,
+            check: this.state.checkResult,
+            unlock: this.state.unlockResult,
+            activate: this.state.activateResult,
+            lockHandle: this.lockHandle,
+            errors: [...this.state.errors]
+        };
+    }
+}
+exports.FunctionGroupBuilder = FunctionGroupBuilder;

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

@@ -0,0 +1,10 @@
+/**
+ * FunctionGroup activation operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Activate function group
+ */
+export declare function activateFunctionGroup(connection: AbapConnection, functionGroupName: string): Promise<AxiosResponse>;
+//# sourceMappingURL=activation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activation.d.ts","sourceRoot":"","sources":["../../../src/core/functionGroup/activation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,cAAc,EAC1B,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAAC,aAAa,CAAC,CAsBxB"}

package/dist/core/functionGroup/activation.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * FunctionGroup activation operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateFunctionGroup = activateFunctionGroup;
+const internalUtils_1 = require("../../utils/internalUtils");
+/**
+ * Activate function group
+ */
+async function activateFunctionGroup(connection, functionGroupName) {
+    const encodedName = (0, internalUtils_1.encodeSapObjectName)(functionGroupName).toLowerCase();
+    const objectUri = `/sap/bc/adt/functions/groups/${encodedName}`;
+    const xmlPayload = `<?xml version="1.0" encoding="UTF-8"?>
+<adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
+  <adtcore:objectReference adtcore:uri="${objectUri}" adtcore:name="${functionGroupName}"/>
+</adtcore:objectReferences>`;
+    const baseUrl = await connection.getBaseUrl();
+    const url = `${baseUrl}/sap/bc/adt/activation?method=activate&preauditRequested=true`;
+    return connection.makeAdtRequest({
+        url,
+        method: 'POST',
+        timeout: 30000, // 30 seconds for activation
+        data: xmlPayload,
+        headers: {
+            'Content-Type': 'application/xml',
+            'Accept': 'application/xml'
+        }
+    });
+}

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

@@ -0,0 +1,24 @@
+/**
+ * FunctionGroup check operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Check function group code (syntax, compilation, rules)
+ *
+ * CheckRun validates everything: syntax, compilation errors, warnings, code quality rules.
+ *
+ * Can check:
+ * - Existing active function group: provide functionGroupName, version='active', omit sourceCode
+ * - Existing inactive function group: provide functionGroupName, version='inactive', omit sourceCode
+ * - Hypothetical code: provide functionGroupName, sourceCode, version (object doesn't need to exist)
+ *
+ * @param connection - SAP connection
+ * @param functionGroupName - Function group 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 checkFunctionGroup(connection: AbapConnection, functionGroupName: string, version: 'active' | 'inactive', sourceCode?: string, sessionId?: string): Promise<AxiosResponse>;
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/core/functionGroup/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,kBAAkB,CACtC,UAAU,EAAE,cAAc,EAC1B,iBAAiB,EAAE,MAAM,EACzB,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,CAAC,CA2CxB"}

package/dist/core/functionGroup/check.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * FunctionGroup 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.checkFunctionGroup = checkFunctionGroup;
+/**
+ * Check function group code (syntax, compilation, rules)
+ *
+ * CheckRun validates everything: syntax, compilation errors, warnings, code quality rules.
+ *
+ * Can check:
+ * - Existing active function group: provide functionGroupName, version='active', omit sourceCode
+ * - Existing inactive function group: provide functionGroupName, version='inactive', omit sourceCode
+ * - Hypothetical code: provide functionGroupName, sourceCode, version (object doesn't need to exist)
+ *
+ * @param connection - SAP connection
+ * @param functionGroupName - Function group 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 checkFunctionGroup(connection, functionGroupName, 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, 'function_group', functionGroupName, sourceCode, version, 'abapCheckRun', sessionId);
+    }
+    else {
+        // Validate existing object in SAP (reads from system)
+        response = await runCheckRun(connection, 'function_group', functionGroupName, version, 'abapCheckRun', sessionId);
+    }
+    const checkResult = parseCheckRunResponse(response);
+    // Check result is OK if:
+    // 1. Message says "has been checked" or "was checked" - object was already checked, this is OK
+    // Problems are: ERROR and WARNING
+    // Only throw error if there are actual ERROR or WARNING messages
+    // If message indicates object was already checked, it's OK (even if has errors/warnings)
+    const isAlreadyChecked = checkResult.message?.toLowerCase().includes('has been checked') ||
+        checkResult.message?.toLowerCase().includes('was checked');
+    if (isAlreadyChecked) {
+        return response; // Object was already checked - this is OK
+    }
+    // Problems: ERROR (errors) and WARNING (warnings)
+    if (checkResult.errors.length > 0) {
+        throw new Error(`Function group check failed: ${checkResult.message || 'Unknown error'}`);
+    }
+    if (checkResult.warnings.length > 0) {
+        throw new Error(`Function group check failed: ${checkResult.message || 'Warnings found'}`);
+    }
+    // If status is 'notProcessed', it's an error
+    if (checkResult.status === 'notProcessed') {
+        throw new Error(`Function group check failed: ${checkResult.message || 'Object could not be processed'}`);
+    }
+    return response;
+}