@mcp-abap-adt/adt-clients 0.1.0

package/dist/core/view/ViewBuilder.js

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * ViewBuilder - Fluent API for view 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 ViewBuilder(connection, logger, {
+ *   viewName: 'Z_TEST_VIEW',
+ *   packageName: 'ZOK_TEST_PKG_01'
+ * });
+ *
+ * await builder
+ *   .setDdlSource('@AbapCatalog.viewType: #BASIC\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.ViewBuilder = 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 ViewBuilder {
+    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(viewName) {
+        this.config.viewName = viewName;
+        this.logger.debug?.('View name set:', viewName);
+        return this;
+    }
+    setDescription(description) {
+        this.config.description = description;
+        return this;
+    }
+    setDdlSource(ddlSource) {
+        this.config.ddlSource = ddlSource;
+        this.logger.debug?.('DDL source set, length:', ddlSource.length);
+        return this;
+    }
+    // Operation methods - return Promise<this> for Promise chaining
+    async validate() {
+        try {
+            this.logger.info?.('Validating view name:', this.config.viewName);
+            const result = await (0, validation_1.validateViewName)(this.connection, this.config.viewName, this.config.description);
+            this.state.validationResult = result;
+            if (!result.valid) {
+                throw new Error(`View name validation failed: ${result.message}`);
+            }
+            this.logger.info?.('View 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.ddlSource) {
+                throw new Error('DDL source is required');
+            }
+            this.logger.info?.('Creating view:', this.config.viewName);
+            const params = {
+                view_name: this.config.viewName,
+                ddl_source: this.config.ddlSource,
+                package_name: this.config.packageName,
+                transport_request: this.config.transportRequest,
+                description: this.config.description
+            };
+            const result = await (0, create_1.createView)(this.connection, params);
+            this.state.createResult = result;
+            this.logger.info?.('View 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 view:', this.config.viewName);
+            const lockHandle = await (0, lock_1.lockDDLS)(this.connection, this.config.viewName, 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?.('View 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('View must be locked before update. Call lock() first.');
+            }
+            if (!this.config.ddlSource) {
+                throw new Error('DDL source is required');
+            }
+            this.logger.info?.('Updating view:', this.config.viewName);
+            const params = {
+                view_name: this.config.viewName,
+                ddl_source: this.config.ddlSource,
+                activate: false,
+                lock_handle: this.lockHandle,
+                session_id: this.sessionId,
+                transport_request: this.config.transportRequest
+            };
+            const result = await (0, update_1.updateViewSource)(this.connection, params);
+            this.state.updateResult = result;
+            this.logger.info?.('View 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 view:', this.config.viewName, 'version:', version);
+            const result = await (0, check_1.checkView)(this.connection, this.config.viewName, version, this.sessionId);
+            this.state.checkResult = result;
+            this.logger.info?.('View 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('View is not locked. Call lock() first.');
+            }
+            this.logger.info?.('Unlocking view:', this.config.viewName);
+            const result = await (0, unlock_1.unlockDDLS)(this.connection, this.config.viewName, this.lockHandle, this.sessionId);
+            this.state.unlockResult = result;
+            this.lockHandle = undefined;
+            this.state.lockHandle = undefined;
+            this.logger.info?.('View 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 view:', this.config.viewName);
+            const result = await (0, activation_1.activateDDLS)(this.connection, this.config.viewName, this.sessionId);
+            this.state.activateResult = result;
+            this.logger.info?.('View 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 view:', this.config.viewName);
+            const result = await (0, read_1.getViewSource)(this.connection, this.config.viewName);
+            this.state.readResult = result;
+            this.logger.info?.('View 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.unlockDDLS)(this.connection, this.config.viewName, this.lockHandle, this.sessionId);
+            this.logger.info?.('Force unlock successful for', this.config.viewName);
+        }
+        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 };
+    }
+    getViewName() {
+        return this.config.viewName;
+    }
+    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.ViewBuilder = ViewBuilder;

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

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

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

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

package/dist/core/view/activation.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * View activation operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateDDLS = activateDDLS;
+const internalUtils_1 = require("../../utils/internalUtils");
+const activationUtils_1 = require("../../utils/activationUtils");
+/**
+ * Activate DDLS
+ */
+async function activateDDLS(connection, viewName, sessionId) {
+    const objectUri = `/sap/bc/adt/ddic/ddl/sources/${(0, internalUtils_1.encodeSapObjectName)(viewName).toLowerCase()}`;
+    return await (0, activationUtils_1.activateObjectInSession)(connection, objectUri, viewName, sessionId, true);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * View check operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+export declare function checkView(connection: AbapConnection, viewName: string, version?: string, sessionId?: string): Promise<AxiosResponse>;
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/core/view/check.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAkBtC,wBAAsB,SAAS,CAC7B,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,MAAiB,EAC1B,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,CAAC,CA2CxB"}

package/dist/core/view/check.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * View check operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkView = checkView;
+const checkRun_1 = require("../shared/checkRun");
+/**
+ * Check view (DDLS) syntax
+ */
+function shouldRetryMissingVersion(checkResult) {
+    if (checkResult.status !== 'notProcessed') {
+        return false;
+    }
+    const message = (checkResult.message || '').toLowerCase();
+    return message.includes('does not exist') || message.includes('missing data definition');
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function checkView(connection, viewName, version = 'active', sessionId) {
+    let attempt = 0;
+    // Allow one retry when system did not materialize inactive version yet
+    while (attempt < 2) {
+        const response = await (0, checkRun_1.runCheckRun)(connection, 'view', viewName, version, 'abapCheckRun', sessionId);
+        const checkResult = (0, checkRun_1.parseCheckRunResponse)(response);
+        if (!checkResult.success && checkResult.has_errors) {
+            const errorMessage = checkResult.message || '';
+            const hasCheckedMessage = errorMessage.toLowerCase().includes('has been checked') ||
+                checkResult.errors.some((err) => (err.text || '').toLowerCase().includes('has been checked'));
+            if (hasCheckedMessage) {
+                if (process.env.DEBUG_TESTS === 'true') {
+                    console.warn(`Check warning for view ${viewName}: ${errorMessage} (view was already checked)`);
+                }
+                return response;
+            }
+            if (attempt === 0 && shouldRetryMissingVersion(checkResult)) {
+                if (process.env.DEBUG_TESTS === 'true') {
+                    console.warn(`Check retry for view ${viewName}: ${errorMessage} (waiting for inactive version)`);
+                }
+                attempt += 1;
+                await delay(2000);
+                continue;
+            }
+            if (shouldRetryMissingVersion(checkResult)) {
+                if (process.env.DEBUG_TESTS === 'true') {
+                    console.warn(`Check warning for view ${viewName}: ${errorMessage} (version not available, continue)`);
+                }
+                return response;
+            }
+            throw new Error(`View check failed: ${checkResult.message}`);
+        }
+        return response;
+    }
+    // Should not reach here because loop returns on success
+    throw new Error(`View check failed: Version ${version} not available for ${viewName}`);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * View create operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+import { CreateViewParams } from './types';
+/**
+ * Create ABAP view (CDS or Classic)
+ * Full workflow: create object -> lock -> upload source -> unlock -> activate
+ */
+export declare function createView(connection: AbapConnection, params: CreateViewParams): Promise<AxiosResponse>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/core/view/create.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAQtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAwD3C;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,aAAa,CAAC,CA6CxB"}

package/dist/core/view/create.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * View create operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createView = createView;
+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");
+/**
+ * Create DDLS object with metadata
+ */
+async function createDDLSObject(connection, args, sessionId) {
+    const description = args.description || args.view_name;
+    const url = `/sap/bc/adt/ddic/ddl/sources${args.transport_request ? `?corrNr=${args.transport_request}` : ''}`;
+    // 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';
+    const masterSystemAttr = masterSystem ? ` adtcore:masterSystem="${masterSystem}"` : '';
+    const responsibleAttr = username ? ` adtcore:responsible="${username}"` : '';
+    const metadataXml = `<?xml version="1.0" encoding="UTF-8"?><ddl:ddlSource xmlns:ddl="http://www.sap.com/adt/ddic/ddlsources" xmlns:adtcore="http://www.sap.com/adt/core" adtcore:description="${description}" adtcore:language="EN" adtcore:name="${args.view_name}" adtcore:type="DDLS/DF" adtcore:masterLanguage="EN"${masterSystemAttr}${responsibleAttr}>
+  <adtcore:packageRef adtcore:name="${args.package_name}"/>
+</ddl:ddlSource>`;
+    const headers = {
+        'Accept': 'application/vnd.sap.adt.ddlSource.v2+xml, application/vnd.sap.adt.ddlSource+xml',
+        'Content-Type': 'application/vnd.sap.adt.ddlSource+xml'
+    };
+    return (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'POST', sessionId, metadataXml, headers);
+}
+/**
+ * Upload DDL source code
+ */
+async function uploadDDLSource(connection, viewName, ddlSource, lockHandle, sessionId, transportRequest) {
+    const queryParams = `lockHandle=${lockHandle}${transportRequest ? `&corrNr=${transportRequest}` : ''}`;
+    const url = `/sap/bc/adt/ddic/ddl/sources/${(0, internalUtils_1.encodeSapObjectName)(viewName).toLowerCase()}/source/main?${queryParams}`;
+    const headers = {
+        'Content-Type': 'text/plain; charset=utf-8'
+    };
+    return (0, sessionUtils_1.makeAdtRequestWithSession)(connection, url, 'PUT', sessionId, ddlSource, headers);
+}
+/**
+ * Create ABAP view (CDS or Classic)
+ * Full workflow: create object -> lock -> upload source -> unlock -> activate
+ */
+async function createView(connection, params) {
+    if (!params.view_name || !params.ddl_source || !params.package_name) {
+        throw new Error('Missing required parameters: view_name, ddl_source, and package_name');
+    }
+    const viewName = params.view_name.toUpperCase();
+    const sessionId = (0, sessionUtils_1.generateSessionId)();
+    let lockHandle = null;
+    try {
+        const createResponse = await createDDLSObject(connection, params, sessionId);
+        if (createResponse.status < 200 || createResponse.status >= 300) {
+            throw new Error(`Failed to create DDLS: ${createResponse.status} ${createResponse.statusText}`);
+        }
+        lockHandle = await (0, lock_1.lockDDLS)(connection, viewName, sessionId);
+        const uploadResponse = await uploadDDLSource(connection, viewName, params.ddl_source, lockHandle, sessionId, params.transport_request);
+        if (uploadResponse.status < 200 || uploadResponse.status >= 300) {
+            throw new Error(`Failed to upload DDL: ${uploadResponse.status} ${uploadResponse.statusText}`);
+        }
+        await (0, unlock_1.unlockDDLS)(connection, viewName, lockHandle, sessionId);
+        lockHandle = null;
+        await (0, activation_1.activateDDLS)(connection, viewName, sessionId);
+        // Return the real response from SAP (from initial POST)
+        return createResponse;
+    }
+    catch (error) {
+        if (lockHandle) {
+            try {
+                await (0, unlock_1.unlockDDLS)(connection, viewName, lockHandle, sessionId);
+            }
+            catch (unlockError) {
+                // Ignore unlock errors
+            }
+        }
+        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 view ${viewName}: ${errorMessage}`);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/core/view/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,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,wBAAsB,UAAU,CAC9B,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,aAAa,CAAC,CAYxB"}

package/dist/core/view/delete.js

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

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

@@ -0,0 +1,15 @@
+/**
+ * View 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 { ViewBuilder, type ViewBuilderConfig, type ViewBuilderLogger, type ViewBuilderState } from './ViewBuilder';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/view/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,WAAW,EAAE,KAAK,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC"}

package/dist/core/view/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * View operations - exports
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewBuilder = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./create"), exports);
+__exportStar(require("./read"), exports);
+__exportStar(require("./update"), exports);
+__exportStar(require("./delete"), exports);
+__exportStar(require("./lock"), exports);
+__exportStar(require("./unlock"), exports);
+__exportStar(require("./activation"), exports);
+__exportStar(require("./check"), exports);
+__exportStar(require("./validation"), exports);
+var ViewBuilder_1 = require("./ViewBuilder");
+Object.defineProperty(exports, "ViewBuilder", { enumerable: true, get: function () { return ViewBuilder_1.ViewBuilder; } });

package/dist/core/view/lock.d.ts

@@ -0,0 +1,18 @@
+/**
+ * View lock operations
+ */
+import { AbapConnection } from '@mcp-abap-adt/connection';
+import { AxiosResponse } from 'axios';
+/**
+ * Lock DDLS for modification
+ */
+export declare function lockDDLS(connection: AbapConnection, viewName: string, sessionId: string): Promise<string>;
+/**
+ * Lock DDLS for editing (for update)
+ */
+export declare function lockDDLSForUpdate(connection: AbapConnection, viewName: string, sessionId: string): Promise<{
+    response: AxiosResponse;
+    lockHandle: string;
+    corrNr?: string;
+}>;
+//# sourceMappingURL=lock.d.ts.map

package/dist/core/view/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../src/core/view/lock.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAKtC;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,CAkBjB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAmB3E"}