@mcp-abap-adt/adt-clients 0.1.0

package/dist/core/shared/whereUsed.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Where-used operations for ABAP objects
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWhereUsed = getWhereUsed;
+const connection_1 = require("@mcp-abap-adt/connection");
+const internalUtils_1 = require("../../utils/internalUtils");
+/**
+ * Build object URI based on type and name
+ */
+function buildObjectUri(objectName, objectType) {
+    const encodedName = (0, internalUtils_1.encodeSapObjectName)(objectName);
+    switch (objectType.toLowerCase()) {
+        case 'class':
+        case 'clas/oc':
+            return `/sap/bc/adt/oo/classes/${encodedName}`;
+        case 'program':
+        case 'prog/p':
+            return `/sap/bc/adt/programs/programs/${encodedName}`;
+        case 'include':
+            return `/sap/bc/adt/programs/includes/${encodedName}`;
+        case 'function':
+        case 'functiongroup':
+        case 'fugr':
+            return `/sap/bc/adt/functions/groups/${encodedName}`;
+        case 'functionmodule':
+        case 'function_module':
+        case 'fugr/ff':
+            if (objectName.includes('|')) {
+                const [group, fm] = objectName.split('|');
+                return `/sap/bc/adt/functions/groups/${(0, internalUtils_1.encodeSapObjectName)(group)}/fmodules/${(0, internalUtils_1.encodeSapObjectName)(fm)}`;
+            }
+            throw new Error('Function module name must be in format GROUP|FM_NAME');
+        case 'interface':
+        case 'intf/if':
+            return `/sap/bc/adt/oo/interfaces/${encodedName}`;
+        case 'package':
+        case 'devc/k':
+            return `/sap/bc/adt/packages/${encodedName}`;
+        case 'table':
+        case 'tabl/dt':
+            return `/sap/bc/adt/ddic/tables/${encodedName}`;
+        case 'structure':
+        case 'stru/dt':
+            return `/sap/bc/adt/ddic/structures/${encodedName}`;
+        case 'domain':
+        case 'doma/dd':
+            return `/sap/bc/adt/ddic/domains/${encodedName}`;
+        case 'dataelement':
+        case 'dtel':
+            return `/sap/bc/adt/ddic/dataelements/${encodedName}`;
+        case 'view':
+        case 'ddls/df':
+            return `/sap/bc/adt/ddic/ddl/sources/${encodedName}`;
+        default:
+            throw new Error(`Unsupported object type for where-used: ${objectType}`);
+    }
+}
+/**
+ * Get where-used references for ABAP object
+ *
+ * @param connection - ABAP connection
+ * @param params - Where-used parameters
+ * @returns Where-used references
+ */
+async function getWhereUsed(connection, params) {
+    if (!params.object_name) {
+        throw new Error('Object name is required');
+    }
+    if (!params.object_type) {
+        throw new Error('Object type is required');
+    }
+    const baseUrl = await connection.getBaseUrl();
+    const objectUri = buildObjectUri(params.object_name, params.object_type);
+    const url = `${baseUrl}/sap/bc/adt/repository/informationsystem/usageReferences?uri=${encodeURIComponent(objectUri)}`;
+    const requestBody = '<?xml version="1.0" encoding="UTF-8"?><usagereferences:usageReferenceRequest xmlns:usagereferences="http://www.sap.com/adt/ris/usageReferences"><usagereferences:affectedObjects/></usagereferences:usageReferenceRequest>';
+    return connection.makeAdtRequest({
+        url,
+        method: 'POST',
+        timeout: (0, connection_1.getTimeout)('default'),
+        data: requestBody,
+        headers: {
+            'Content-Type': 'application/xml',
+            'Accept': 'application/xml'
+        }
+    });
+}

package/dist/core/structure/StructureBuilder.d.ts

@@ -0,0 +1,124 @@
+/**
+ * StructureBuilder - Fluent API for structure 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 StructureBuilder(connection, logger, {
+ *   structureName: 'Z_TEST_STRUCT',
+ *   packageName: 'ZOK_TEST_PKG_01'
+ * });
+ *
+ * await builder
+ *   .setFields([{ name: 'FIELD1', data_type: 'CHAR', length: 10 }])
+ *   .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);
+ *   });
+ * ```
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+import { StructureField, StructureInclude } from './types';
+import { ValidationResult } from '../shared/validation';
+export interface StructureBuilderLogger {
+    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 StructureBuilderConfig {
+    structureName: string;
+    packageName?: string;
+    transportRequest?: string;
+    description?: string;
+    ddlCode?: string;
+    fields?: StructureField[];
+    includes?: StructureInclude[];
+    sessionId?: string;
+    onLock?: (lockHandle: string, sessionId: string) => void;
+}
+export interface StructureBuilderState {
+    validationResult?: ValidationResult;
+    createResult?: AxiosResponse;
+    lockHandle?: string;
+    updateResult?: AxiosResponse;
+    checkResult?: AxiosResponse;
+    unlockResult?: AxiosResponse;
+    activateResult?: AxiosResponse;
+    readResult?: AxiosResponse;
+    errors: Array<{
+        method: string;
+        error: Error;
+        timestamp: Date;
+    }>;
+}
+export declare class StructureBuilder {
+    private connection;
+    private logger;
+    private config;
+    private lockHandle?;
+    private sessionId;
+    private state;
+    constructor(connection: AbapConnection, logger: StructureBuilderLogger, config: StructureBuilderConfig);
+    setPackage(packageName: string): this;
+    setRequest(transportRequest: string): this;
+    setName(structureName: string): this;
+    setDescription(description: string): this;
+    setDdlCode(ddlCode: string): this;
+    setFields(fields: StructureField[]): this;
+    setIncludes(includes: StructureInclude[]): this;
+    addField(field: StructureField): this;
+    addInclude(include: StructureInclude): this;
+    validate(): Promise<this>;
+    create(): Promise<this>;
+    lock(): Promise<this>;
+    update(ddlCode?: string): Promise<this>;
+    check(version?: 'active' | 'inactive'): Promise<this>;
+    unlock(): Promise<this>;
+    activate(): Promise<this>;
+    read(version?: 'active' | 'inactive'): Promise<this>;
+    forceUnlock(): Promise<void>;
+    getState(): Readonly<StructureBuilderState>;
+    getStructureName(): string;
+    getLockHandle(): string | undefined;
+    getSessionId(): string;
+    getValidationResult(): ValidationResult | undefined;
+    getCreateResult(): AxiosResponse | undefined;
+    getUpdateResult(): AxiosResponse | undefined;
+    getCheckResult(): AxiosResponse | undefined;
+    getUnlockResult(): AxiosResponse | undefined;
+    getActivateResult(): AxiosResponse | undefined;
+    getReadResult(): AxiosResponse | undefined;
+    getErrors(): ReadonlyArray<{
+        method: string;
+        error: Error;
+        timestamp: Date;
+    }>;
+    getResults(): {
+        validate?: ValidationResult;
+        create?: AxiosResponse;
+        update?: AxiosResponse;
+        check?: AxiosResponse;
+        unlock?: AxiosResponse;
+        activate?: AxiosResponse;
+        lockHandle?: string;
+        errors: Array<{
+            method: string;
+            error: Error;
+            timestamp: Date;
+        }>;
+    };
+}
+//# sourceMappingURL=StructureBuilder.d.ts.map

package/dist/core/structure/StructureBuilder.d.ts.map

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

package/dist/core/structure/StructureBuilder.js

@@ -0,0 +1,357 @@
+"use strict";
+/**
+ * StructureBuilder - Fluent API for structure 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 StructureBuilder(connection, logger, {
+ *   structureName: 'Z_TEST_STRUCT',
+ *   packageName: 'ZOK_TEST_PKG_01'
+ * });
+ *
+ * await builder
+ *   .setFields([{ name: 'FIELD1', data_type: 'CHAR', length: 10 }])
+ *   .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);
+ *   });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureBuilder = 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("./validation");
+const read_1 = require("./read");
+class StructureBuilder {
+    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(structureName) {
+        this.config.structureName = structureName;
+        this.logger.debug?.('Structure name set:', structureName);
+        return this;
+    }
+    setDescription(description) {
+        this.config.description = description;
+        return this;
+    }
+    setDdlCode(ddlCode) {
+        this.config.ddlCode = ddlCode;
+        this.logger.debug?.('DDL code set');
+        return this;
+    }
+    setFields(fields) {
+        this.config.fields = fields;
+        this.logger.debug?.('Fields set:', fields.length);
+        return this;
+    }
+    setIncludes(includes) {
+        this.config.includes = includes;
+        this.logger.debug?.('Includes set:', includes.length);
+        return this;
+    }
+    addField(field) {
+        if (!this.config.fields) {
+            this.config.fields = [];
+        }
+        this.config.fields.push(field);
+        return this;
+    }
+    addInclude(include) {
+        if (!this.config.includes) {
+            this.config.includes = [];
+        }
+        this.config.includes.push(include);
+        return this;
+    }
+    // Operation methods - return Promise<this> for Promise chaining
+    async validate() {
+        try {
+            this.logger.info?.('Validating structure name:', this.config.structureName);
+            const result = await (0, validation_1.validateStructureName)(this.connection, this.config.structureName, this.config.description);
+            this.state.validationResult = result;
+            if (!result.valid) {
+                throw new Error(`Structure name validation failed: ${result.message}`);
+            }
+            this.logger.info?.('Structure 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;
+        }
+    }
+    async create() {
+        try {
+            if (!this.config.packageName) {
+                throw new Error('Package name is required');
+            }
+            if (!this.config.ddlCode) {
+                throw new Error('DDL code is required');
+            }
+            this.logger.info?.('Creating structure:', this.config.structureName);
+            const params = {
+                structure_name: this.config.structureName,
+                package_name: this.config.packageName,
+                transport_request: this.config.transportRequest,
+                description: this.config.description,
+                ddl_code: this.config.ddlCode
+            };
+            const result = await (0, create_1.createStructure)(this.connection, params);
+            this.state.createResult = result;
+            this.logger.info?.('Structure 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;
+        }
+    }
+    async lock() {
+        try {
+            this.logger.info?.('Locking structure:', this.config.structureName);
+            const lockHandle = await (0, lock_1.lockStructure)(this.connection, this.config.structureName, 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?.('Structure 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;
+        }
+    }
+    async update(ddlCode) {
+        try {
+            if (!this.lockHandle) {
+                throw new Error('Structure must be locked before update. Call lock() first.');
+            }
+            const code = ddlCode || this.config.ddlCode;
+            if (!code) {
+                throw new Error('DDL code is required. Use setDdlCode() or pass as parameter.');
+            }
+            this.logger.info?.('Updating structure:', this.config.structureName);
+            const params = {
+                structure_name: this.config.structureName,
+                ddl_code: code,
+                transport_request: this.config.transportRequest
+            };
+            const result = await (0, update_1.updateStructure)(this.connection, params, this.lockHandle, this.sessionId);
+            this.state.updateResult = result;
+            this.logger.info?.('Structure 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;
+        }
+    }
+    async check(version = 'inactive') {
+        try {
+            this.logger.info?.('Checking structure:', this.config.structureName, 'version:', version);
+            const result = await (0, check_1.checkStructure)(this.connection, this.config.structureName, version, this.sessionId);
+            this.state.checkResult = result;
+            this.logger.info?.('Structure 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;
+        }
+    }
+    async unlock() {
+        try {
+            if (!this.lockHandle) {
+                throw new Error('Structure is not locked. Call lock() first.');
+            }
+            this.logger.info?.('Unlocking structure:', this.config.structureName);
+            const result = await (0, unlock_1.unlockStructure)(this.connection, this.config.structureName, this.lockHandle, this.sessionId);
+            this.state.unlockResult = result;
+            this.lockHandle = undefined;
+            this.state.lockHandle = undefined;
+            this.logger.info?.('Structure 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;
+        }
+    }
+    async activate() {
+        try {
+            this.logger.info?.('Activating structure:', this.config.structureName);
+            const result = await (0, activation_1.activateStructure)(this.connection, this.config.structureName, this.sessionId);
+            this.state.activateResult = result;
+            this.logger.info?.('Structure 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;
+        }
+    }
+    async read(version = 'active') {
+        try {
+            this.logger.info?.('Reading structure:', this.config.structureName);
+            const result = await (0, read_1.getStructureSource)(this.connection, this.config.structureName);
+            this.state.readResult = result;
+            this.logger.info?.('Structure 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;
+        }
+    }
+    async forceUnlock() {
+        if (!this.lockHandle) {
+            return;
+        }
+        try {
+            await (0, unlock_1.unlockStructure)(this.connection, this.config.structureName, this.lockHandle, this.sessionId);
+            this.logger.info?.('Force unlock successful for', this.config.structureName);
+        }
+        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 };
+    }
+    getStructureName() {
+        return this.config.structureName;
+    }
+    getLockHandle() {
+        return this.lockHandle;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getValidationResult() {
+        return this.state.validationResult;
+    }
+    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;
+    }
+    getErrors() {
+        return [...this.state.errors];
+    }
+    getResults() {
+        return {
+            validate: this.state.validationResult,
+            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.StructureBuilder = StructureBuilder;

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

@@ -0,0 +1,10 @@
+/**
+ * Structure activation operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Activate the structure after creation
+ */
+export declare function activateStructure(connection: AbapConnection, structureName: string, sessionId: string): Promise<AxiosResponse>;
+//# sourceMappingURL=activation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activation.d.ts","sourceRoot":"","sources":["../../../src/core/structure/activation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAItC;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CAGxB"}

package/dist/core/structure/activation.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Structure activation operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateStructure = activateStructure;
+const internalUtils_1 = require("../../utils/internalUtils");
+const activationUtils_1 = require("../../utils/activationUtils");
+/**
+ * Activate the structure after creation
+ */
+async function activateStructure(connection, structureName, sessionId) {
+    const objectUri = `/sap/bc/adt/ddic/structures/${(0, internalUtils_1.encodeSapObjectName)(structureName)}`;
+    return await (0, activationUtils_1.activateObjectInSession)(connection, objectUri, structureName, sessionId, true);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Structure check operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Check structure syntax
+ * Note: For DDIC objects like structures, check may not be fully supported in all SAP systems.
+ * If check fails with "inactive version does not exist" or "importing from database" error, it's often safe to skip.
+ */
+export declare function checkStructure(connection: AbapConnection, structureName: string, version?: string, sessionId?: string): Promise<AxiosResponse>;
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/core/structure/check.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,MAAiB,EAC1B,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,CAAC,CAmCxB"}

package/dist/core/structure/check.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Structure check operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkStructure = checkStructure;
+const checkRun_1 = require("../shared/checkRun");
+/**
+ * Check structure syntax
+ * Note: For DDIC objects like structures, check may not be fully supported in all SAP systems.
+ * If check fails with "inactive version does not exist" or "importing from database" error, it's often safe to skip.
+ */
+async function checkStructure(connection, structureName, version = 'active', sessionId) {
+    const response = await (0, checkRun_1.runCheckRun)(connection, 'structure', structureName, version, 'abapCheckRun', sessionId);
+    const checkResult = (0, checkRun_1.parseCheckRunResponse)(response);
+    if (!checkResult.success && checkResult.has_errors) {
+        // For DDIC objects, "inactive version does not exist", "importing from database", or "has been checked" errors
+        // are often non-critical and can be safely ignored, especially for inactive versions
+        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 - structure was already checked, return response anyway
+            if (process.env.DEBUG_TESTS === 'true') {
+                console.warn(`Check warning for structure ${structureName}: ${errorMessage} (structure was already checked)`);
+            }
+            return response; // Return response anyway
+        }
+        if ((errorMessage.toLowerCase().includes('inactive version') &&
+            errorMessage.toLowerCase().includes('does not exist')) ||
+            (errorMessage.toLowerCase().includes('importing') &&
+                errorMessage.toLowerCase().includes('database'))) {
+            // This is expected behavior for DDIC objects - check may not be fully supported
+            // Return response without throwing - test chain can continue
+            if (process.env.DEBUG_TESTS === 'true') {
+                console.warn(`Check warning for structure ${structureName}: ${errorMessage} (check may not be fully supported for DDIC objects)`);
+            }
+            return response; // Return response anyway
+        }
+        throw new Error(`Structure check failed: ${checkResult.message}`);
+    }
+    return response;
+}