@mcp-abap-adt/adt-clients 0.1.0

package/dist/core/table/TableBuilder.d.ts.map

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

package/dist/core/table/TableBuilder.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * TableBuilder - Fluent API for table 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 TableBuilder(connection, logger, {
+ *   tableName: 'Z_TEST_TABLE',
+ *   packageName: 'ZOK_TEST_PKG_01'
+ * });
+ *
+ * await builder
+ *   .setDdlCode('@AbapCatalog.tableType : #TRANSPARENT\n...')
+ *   .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.TableBuilder = 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 TableBuilder {
+    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(tableName) {
+        this.config.tableName = tableName;
+        this.logger.debug?.('Table name set:', tableName);
+        return this;
+    }
+    setDdlCode(ddlCode) {
+        this.config.ddlCode = ddlCode;
+        this.logger.debug?.('DDL code set, length:', ddlCode.length);
+        return this;
+    }
+    // Operation methods - return Promise<this> for Promise chaining
+    async validate() {
+        try {
+            this.logger.info?.('Validating table name:', this.config.tableName);
+            const result = await (0, validation_1.validateTableName)(this.connection, this.config.tableName);
+            this.state.validationResult = result;
+            if (!result.valid) {
+                throw new Error(`Table name validation failed: ${result.message}`);
+            }
+            this.logger.info?.('Table 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 table:', this.config.tableName);
+            const params = {
+                table_name: this.config.tableName,
+                ddl_code: this.config.ddlCode,
+                package_name: this.config.packageName,
+                transport_request: this.config.transportRequest
+            };
+            const result = await (0, create_1.createTable)(this.connection, params);
+            this.state.createResult = result;
+            this.logger.info?.('Table 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 table:', this.config.tableName);
+            const lockHandle = await (0, lock_1.acquireTableLockHandle)(this.connection, this.config.tableName, 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?.('Table 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() {
+        try {
+            if (!this.lockHandle) {
+                throw new Error('Table must be locked before update. Call lock() first.');
+            }
+            if (!this.config.ddlCode) {
+                throw new Error('DDL code is required');
+            }
+            this.logger.info?.('Updating table:', this.config.tableName);
+            const params = {
+                table_name: this.config.tableName,
+                ddl_code: this.config.ddlCode,
+                transport_request: this.config.transportRequest,
+                activate: false
+            };
+            const result = await (0, update_1.updateTable)(this.connection, params, this.lockHandle, this.sessionId);
+            this.state.updateResult = result;
+            this.logger.info?.('Table 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(reporter = 'abapCheckRun') {
+        try {
+            this.logger.info?.('Checking table:', this.config.tableName, 'reporter:', reporter);
+            const result = await (0, check_1.runTableCheckRun)(this.connection, reporter, this.config.tableName, this.sessionId);
+            this.state.checkResult = result;
+            this.logger.info?.('Table 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('Table is not locked. Call lock() first.');
+            }
+            this.logger.info?.('Unlocking table:', this.config.tableName);
+            const result = await (0, unlock_1.unlockTable)(this.connection, this.config.tableName, this.lockHandle, this.sessionId);
+            this.state.unlockResult = result;
+            this.lockHandle = undefined;
+            this.state.lockHandle = undefined;
+            this.logger.info?.('Table 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 table:', this.config.tableName);
+            const result = await (0, activation_1.activateTable)(this.connection, this.config.tableName, this.sessionId);
+            this.state.activateResult = result;
+            this.logger.info?.('Table 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 table:', this.config.tableName);
+            const result = await (0, read_1.getTableSource)(this.connection, this.config.tableName);
+            this.state.readResult = result;
+            this.logger.info?.('Table 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.unlockTable)(this.connection, this.config.tableName, this.lockHandle, this.sessionId);
+            this.logger.info?.('Force unlock successful for', this.config.tableName);
+        }
+        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 };
+    }
+    getTableName() {
+        return this.config.tableName;
+    }
+    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.TableBuilder = TableBuilder;

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

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

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

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

package/dist/core/table/activation.js

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

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

@@ -0,0 +1,11 @@
+/**
+ * Table check operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Run check run for table
+ * Note: This is a table-specific check function. For generic check, use runCheckRun from shared/checkRun
+ */
+export declare function runTableCheckRun(connection: AbapConnection, reporter: 'tableStatusCheck' | 'abapCheckRun', tableName: string, sessionId: string): Promise<AxiosResponse>;
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/core/table/check.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAetC;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,kBAAkB,GAAG,cAAc,EAC7C,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CAQxB"}

package/dist/core/table/check.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Table check operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTableCheckRun = runTableCheckRun;
+const internalUtils_1 = require("../../utils/internalUtils");
+const sessionUtils_1 = require("../../utils/sessionUtils");
+/**
+ * Build check run XML payload
+ */
+function buildCheckRunPayload(tableName) {
+    const uriName = (0, internalUtils_1.encodeSapObjectName)(tableName).toLowerCase();
+    return `<?xml version="1.0" encoding="UTF-8"?><chkrun:checkObjectList xmlns:chkrun="http://www.sap.com/adt/checkrun" xmlns:adtcore="http://www.sap.com/adt/core">
+    <chkrun:checkObject adtcore:uri="/sap/bc/adt/ddic/tables/${uriName}" chkrun:version="new"/>
+  </chkrun:checkObjectList>`;
+}
+/**
+ * Run check run for table
+ * Note: This is a table-specific check function. For generic check, use runCheckRun from shared/checkRun
+ */
+async function runTableCheckRun(connection, reporter, tableName, sessionId) {
+    const payload = buildCheckRunPayload(tableName);
+    const headers = {
+        'Accept': 'application/vnd.sap.adt.checkmessages+xml',
+        'Content-Type': 'application/vnd.sap.adt.checkobjects+xml'
+    };
+    const url = `/sap/bc/adt/checkruns?reporters=${reporter}`;
+    return (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'POST', sessionId, payload, headers);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Table create operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+import { CreateTableParams } from './types';
+/**
+ * Create ABAP table
+ * Full workflow: create empty -> check status -> lock -> add DDL -> check -> unlock -> activate -> verify
+ */
+export declare function createTable(connection: AbapConnection, params: CreateTableParams): Promise<AxiosResponse>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/core/table/create.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAc,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAQtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AA+D5C;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,aAAa,CAAC,CA6HxB"}

package/dist/core/table/create.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Table create operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTable = createTable;
+const connection_1 = require("@mcp-abap-adt/connection");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const internalUtils_1 = require("../../utils/internalUtils");
+const sessionUtils_1 = require("../../utils/sessionUtils");
+const lock_1 = require("./lock");
+const unlock_1 = require("./unlock");
+const activation_1 = require("./activation");
+const check_1 = require("./check");
+/**
+ * Parse XML response to extract table creation information
+ */
+function parseTableCreationResponse(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        parseAttributeValue: true,
+        trimValues: true
+    });
+    try {
+        const result = parser.parse(xml);
+        if (result.error || result['asx:abap']?.['asx:values']?.ERROR) {
+            const errorMsg = result.error?.message ||
+                result['asx:abap']?.['asx:values']?.ERROR?.MESSAGE ||
+                'Unknown error during table creation';
+            throw new Error(errorMsg);
+        }
+        if (result['ddic:table']) {
+            const table = result['ddic:table'];
+            return {
+                name: table['adtcore:name'],
+                description: table['adtcore:description'],
+                package: table['adtcore:packageRef']?.['adtcore:name'],
+                status: 'created',
+                objectType: 'table'
+            };
+        }
+        return { raw: result, status: 'created' };
+    }
+    catch (parseError) {
+        return {
+            raw_xml: xml,
+            status: 'created',
+            note: 'XML parsing failed, but table creation might have succeeded'
+        };
+    }
+}
+/**
+ * Verify table exists and get its details
+ */
+async function verifyTableCreation(connection, tableName) {
+    const baseUrl = await connection.getBaseUrl();
+    const url = `${baseUrl}/sap/bc/adt/ddic/tables/${(0, internalUtils_1.encodeSapObjectName)(tableName)}/source/main`;
+    return connection.makeAdtRequest({
+        url,
+        method: 'GET',
+        timeout: (0, connection_1.getTimeout)('default'),
+        headers: {}
+    });
+}
+/**
+ * Create ABAP table
+ * Full workflow: create empty -> check status -> lock -> add DDL -> check -> unlock -> activate -> verify
+ */
+async function createTable(connection, params) {
+    if (!params.table_name) {
+        throw new Error('Table name is required');
+    }
+    if (!params.ddl_code) {
+        throw new Error('DDL code is required');
+    }
+    if (!params.package_name) {
+        throw new Error('Package name is required');
+    }
+    const sessionId = (0, sessionUtils_1.generateSessionId)();
+    let lockHandle = null;
+    try {
+        // Step 1: Create empty table with POST
+        const createUrl = `/sap/bc/adt/ddic/tables${params.transport_request ? `?corrNr=${params.transport_request}` : ''}`;
+        const tableXml = `<?xml version="1.0" encoding="UTF-8"?><blue:blueSource xmlns:blue="http://www.sap.com/wbobj/blue" xmlns:adtcore="http://www.sap.com/adt/core" adtcore:description="${params.table_name}" adtcore:language="EN" adtcore:name="${params.table_name.toUpperCase()}" adtcore:type="TABL/DT" adtcore:masterLanguage="EN" adtcore:masterSystem="${process.env.SAP_SYSTEM || process.env.SAP_SYSTEM_ID || 'DEV'}" adtcore:responsible="${process.env.SAP_USER || process.env.SAP_USERNAME || 'DEVELOPER'}">
+
+  <adtcore:packageRef adtcore:name="${params.package_name.toUpperCase()}"/>
+
+</blue:blueSource>`;
+        const headers = {
+            'Accept': 'application/vnd.sap.adt.blues.v1+xml, application/vnd.sap.adt.tables.v2+xml',
+            'Content-Type': 'application/vnd.sap.adt.tables.v2+xml'
+        };
+        const createResponse = await (0, sessionUtils_1.makeAdtRequestWithSession)(connection, createUrl, 'POST', sessionId, tableXml, headers);
+        // Step 1.1: Run table status check before locking (optional, continue on error)
+        try {
+            await (0, check_1.runTableCheckRun)(connection, 'tableStatusCheck', params.table_name, sessionId);
+        }
+        catch (statusError) {
+            // Continue even if status check fails
+        }
+        // Step 1.2: Get lockHandle for the created table
+        lockHandle = await (0, lock_1.acquireTableLockHandle)(connection, params.table_name, sessionId);
+        // Step 1.3: Add DDL content to the table with lockHandle
+        const ddlUrl = `/sap/bc/adt/ddic/tables/${(0, internalUtils_1.encodeSapObjectName)(params.table_name)}/source/main?lockHandle=${lockHandle}${params.transport_request ? `&corrNr=${params.transport_request}` : ''}`;
+        const ddlHeaders = {
+            'Accept': 'application/xml, application/json, text/plain, */*',
+            'Content-Type': 'text/plain; charset=utf-8'
+        };
+        const ddlResponse = await (0, sessionUtils_1.makeAdtRequestWithSession)(connection, ddlUrl, 'PUT', sessionId, params.ddl_code, ddlHeaders);
+        parseTableCreationResponse(ddlResponse.data);
+        // Step 1.3.1: Run ABAP check before unlock (optional, continue on error)
+        try {
+            await (0, check_1.runTableCheckRun)(connection, 'abapCheckRun', params.table_name, sessionId);
+        }
+        catch (checkError) {
+            // Continue even if check fails
+        }
+        // Step 1.4: Unlock the table after DDL content is added
+        try {
+            await (0, unlock_1.unlockTable)(connection, params.table_name, lockHandle, sessionId);
+            lockHandle = null;
+        }
+        catch (unlockError) {
+            try {
+                await (0, unlock_1.deleteTableLock)(connection, params.table_name);
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors
+            }
+        }
+        // Step 2: Activate table
+        let activationAttempt = 0;
+        const maxActivationAttempts = 2;
+        while (activationAttempt < maxActivationAttempts) {
+            activationAttempt++;
+            try {
+                await (0, activation_1.activateTable)(connection, params.table_name, sessionId);
+                break;
+            }
+            catch (attemptError) {
+                if (attemptError.response?.data?.includes('No active nametab')) {
+                    try {
+                        await (0, check_1.runTableCheckRun)(connection, 'abapCheckRun', params.table_name, sessionId);
+                    }
+                    catch (retryCheckError) {
+                        // Ignore
+                    }
+                    if (activationAttempt < maxActivationAttempts) {
+                        continue;
+                    }
+                }
+                if (activationAttempt >= maxActivationAttempts) {
+                    break;
+                }
+                throw attemptError;
+            }
+        }
+        // Return the real response from SAP (from initial POST)
+        return createResponse;
+    }
+    catch (error) {
+        // Try to unlock if we have a lock handle
+        if (lockHandle) {
+            try {
+                await (0, unlock_1.unlockTable)(connection, params.table_name, lockHandle, sessionId);
+            }
+            catch (unlockError) {
+                try {
+                    await (0, unlock_1.deleteTableLock)(connection, params.table_name);
+                }
+                catch (cleanupError) {
+                    // Ignore
+                }
+            }
+        }
+        const errorMessage = error.response?.data
+            ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+            : error.message;
+        throw new Error(`Failed to create table ${params.table_name}: ${errorMessage}`);
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Table delete operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+export interface DeleteTableParams {
+    table_name: string;
+    transport_request?: string;
+}
+/**
+ * Delete ABAP table
+ */
+export declare function deleteTable(connection: AbapConnection, params: DeleteTableParams): Promise<AxiosResponse>;
+//# sourceMappingURL=delete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/core/table/delete.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,aAAa,CAAC,CAYxB"}

package/dist/core/table/delete.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Table delete operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTable = deleteTable;
+const delete_1 = require("../delete");
+/**
+ * Delete ABAP table
+ */
+async function deleteTable(connection, params) {
+    if (!params.table_name) {
+        throw new Error('table_name is required');
+    }
+    const deleteParams = {
+        object_name: params.table_name,
+        object_type: 'TABL/DT',
+        transport_request: params.transport_request
+    };
+    return await (0, delete_1.deleteObject)(connection, deleteParams);
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Table operations - exports
+ */
+export * from './types';
+export * from './create';
+export * from './read';
+export * from './update';
+export * from './delete';
+export * from './lock';
+export * from './unlock';
+export * from './activation';
+export * from './check';
+export * from './validation';
+export { TableBuilder, type TableBuilderConfig, type TableBuilderLogger, type TableBuilderState } from './TableBuilder';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/table/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}