@mcp-abap-adt/adt-clients 0.1.40 → 0.2.0

package/README.md

@@ -92,19 +92,26 @@ See [CLI Tools documentation](./bin/README.md) for details.
 
 ### Three-Layer API
 
-1. **Builders** (Low-level, flexible)
+1. **AdtClient** (High-level, recommended)
+   - Simplified CRUD operations with automatic operation chains
+   - Factory pattern: `client.getClass()`, `client.getProgram()`, etc.
+   - Automatic error handling and resource cleanup
+   - Utility functions via `client.getUtils()`
+   - Example: `await client.getClass().create({...}, { activateOnCreate: true })`
+
+2. **Builders** (Low-level, flexible)
    - Direct access to all ADT operations
    - Method chaining with Promise support
    - Fine-grained control over workflow
    - Example: `ProgramBuilder`, `ClassBuilder`, `InterfaceBuilder`
 
-2. **Clients** (High-level, convenient)
+3. **Clients** (Legacy API)
    - **ReadOnlyClient** – simple read operations
    - **CrudClient** – unified CRUD operations with chaining
    - State management with getters
    - Example: `client.createProgram(...).lockProgram(...).updateProgram(...)`
 
-3. **Specialized Clients**
+4. **Specialized Clients**
    - `ManagementClient` – activation, syntax checking
    - `LockClient` – lock/unlock with registry
    - `ValidationClient` – object name validation
@@ -131,7 +138,43 @@ See [CLI Tools documentation](./bin/README.md) for details.
 
 ## Quick Start
 
-### Using CrudClient (Recommended for most cases)
+### Using AdtClient (Recommended - High-Level CRUD API)
+
+```typescript
+import { createAbapConnection } from '@mcp-abap-adt/connection';
+import { AdtClient } from '@mcp-abap-adt/adt-clients';
+
+const connection = createAbapConnection({
+  url: 'https://your-sap-system.example.com',
+  client: '100',
+  authType: 'basic',
+  username: process.env.SAP_USERNAME!,
+  password: process.env.SAP_PASSWORD!
+}, console);
+
+const client = new AdtClient(connection, console);
+
+// Simple CRUD operations with automatic operation chains
+await client.getClass().create({
+  className: 'ZCL_TEST',
+  packageName: 'ZPACKAGE',
+  description: 'Test class'
+}, { activateOnCreate: true });
+
+// Utility functions
+const utils = client.getUtils();
+await utils.searchObjects({ query: 'Z*', objectType: 'CLAS' });
+await utils.getWhereUsed({ objectName: 'ZCL_TEST', objectType: 'CLAS' });
+```
+
+**Benefits:**
+- ✅ Simplified API - no manual lock/unlock management
+- ✅ Automatic operation chains (validate → create → check → lock → update → unlock → activate)
+- ✅ Consistent error handling and resource cleanup
+- ✅ Separation of CRUD operations and utility functions
+- ✅ Long polling support for object readiness
+
+### Using CrudClient (Builder-based API)
 
 ```typescript
 import { createAbapConnection } from '@mcp-abap-adt/connection';
@@ -174,6 +217,44 @@ const classDefinition = await client.readClass('ZCL_TEST_CLASS');
 const interfaceCode = await client.readInterface('ZIF_TEST_INTERFACE');
 ```
 
+### Using Long Polling for Object Readiness
+
+The `withLongPolling` parameter allows you to wait for objects to become available after create/update/activate operations, replacing fixed timeouts with server-driven waiting:
+
+```typescript
+import { AdtClient } from '@mcp-abap-adt/adt-clients';
+
+const client = new AdtClient(connection);
+
+// Create a class
+await client.getClass().create({
+  className: 'ZCL_TEST',
+  packageName: 'ZPACKAGE',
+  description: 'Test class'
+});
+
+// Wait for object to be ready using long polling
+// The server will hold the connection until the object is available
+await client.getClass().read(
+  { className: 'ZCL_TEST' },
+  'active',
+  { withLongPolling: true }
+);
+
+// Now the object is guaranteed to be ready for subsequent operations
+await client.getClass().update({
+  className: 'ZCL_TEST'
+}, { sourceCode: updatedCode });
+```
+
+**Benefits of Long Polling:**
+- ✅ **No arbitrary timeouts** - waits for actual object readiness
+- ✅ **Faster tests** - no unnecessary delays when object is ready quickly
+- ✅ **More reliable** - server-driven waiting ensures object is actually available
+- ✅ **Automatic in create/update** - `AdtObject` implementations use long polling internally
+
+**Note:** Long polling is automatically used in `create()` and `update()` methods of all `AdtObject` implementations to ensure objects are ready before proceeding with subsequent operations.
+
 ### Using Builders (Advanced workflows)
 
 ```typescript
@@ -269,6 +350,56 @@ adt-manage-sessions cleanup
 
 See [bin/README.md](bin/README.md) for details.
 
+## Developer Tools
+
+### ADT Discovery Script
+
+The package includes a tool for generating documentation from the ADT discovery endpoint, which lists all available ADT API endpoints.
+
+**Purpose:** Explore available ADT API endpoints and generate markdown documentation.
+
+**Usage:**
+```bash
+# Generate discovery documentation (default output: docs/architecture/discovery.md)
+npm run discovery:markdown
+
+# Custom output file
+npm run discovery:markdown -- --output custom-discovery.md
+
+# Custom SAP system URL
+npm run discovery:markdown -- --url https://your-system.com
+
+# Custom .env file
+npm run discovery:markdown -- --env /path/to/.env
+```
+
+**What it does:**
+1. Connects to the SAP system using credentials from `.env` file
+2. Fetches the discovery endpoint: `GET /sap/bc/adt/discovery`
+3. Parses the XML response
+4. Converts it to readable markdown with endpoint categories, HTTP methods, URLs, content types, and descriptions
+
+**Output:** 
+- Default: `docs/architecture/discovery.md`
+- Custom: Path specified via `--output` option
+
+**Environment Variables:**
+The script uses the same environment variables as the main package:
+- `SAP_URL` - SAP system URL (required)
+- `SAP_AUTH_TYPE` - Authentication type: `'basic'` or `'jwt'` (default: `'basic'`)
+- `SAP_USERNAME` - Username for basic auth
+- `SAP_PASSWORD` - Password for basic auth
+- `SAP_JWT_TOKEN` - JWT token for JWT auth
+- `SAP_CLIENT` - Client number (optional)
+
+**When to use:**
+- To explore available ADT API endpoints on your SAP system
+- To generate up-to-date documentation for ADT API
+- To understand the structure of ADT discovery responses
+- To verify endpoint availability on a specific SAP system
+
+See [Tools Documentation](tools/README.md) for complete details and options.
+
 ## API Reference
 
 ### CrudClient Methods
@@ -319,6 +450,27 @@ See [bin/README.md](bin/README.md) for details.
 - `readPackage(name)` → `Promise<AxiosResponse>`
 - `readTransport(transportRequest)` → `Promise<AxiosResponse>`
 
+### AdtObject Methods (with Long Polling Support)
+
+All `AdtObject` implementations support the `withLongPolling` parameter for read operations:
+
+```typescript
+// Read with long polling - waits for object to be ready
+await adtObject.read(config, 'active', { withLongPolling: true });
+
+// Read metadata with long polling
+await adtObject.readMetadata(config, { withLongPolling: true });
+
+// Read transport info with long polling
+await adtObject.readTransport(config, { withLongPolling: true });
+```
+
+**When to use long polling:**
+- After `create()` operations - wait for object to be available
+- After `update()` operations - wait for changes to be persisted
+- After `activate()` operations - wait for object to be available in active version
+- In tests - replace fixed `setTimeout` delays with long polling for better reliability
+
 ### Specialized Clients
 
 - **ManagementClient**: batch activation + check operations
@@ -384,6 +536,37 @@ See [Architecture Documentation](docs/architecture/ARCHITECTURE.md#type-system-o
 
 ## Migration Guide
 
+### From Timeouts to Long Polling
+
+**Migration from fixed timeouts to long polling:**
+
+The package now uses long polling (`?withLongPolling=true`) instead of fixed timeouts for waiting object readiness. This provides better reliability and faster execution.
+
+```typescript
+// ❌ Before - Using fixed timeouts
+await client.getClass().create({ className: 'ZCL_TEST', ... });
+await new Promise(resolve => setTimeout(resolve, 2000)); // Fixed delay
+await client.getClass().update({ className: 'ZCL_TEST' }, { sourceCode });
+
+// ✅ After - Using long polling
+await client.getClass().create({ className: 'ZCL_TEST', ... });
+// Long polling is automatically used in create/update methods
+await client.getClass().update({ className: 'ZCL_TEST' }, { sourceCode });
+
+// Or explicitly use long polling in read operations
+await client.getClass().read(
+  { className: 'ZCL_TEST' },
+  'active',
+  { withLongPolling: true }
+);
+```
+
+**Benefits:**
+- No arbitrary delays - waits for actual object readiness
+- Faster execution when objects are ready quickly
+- More reliable - server-driven waiting ensures object is available
+- Automatic in `create()` and `update()` methods
+
 ### From v0.1.0 to v0.2.0
 
 **Breaking Changes:**

package/dist/clients/AdtClient.d.ts

@@ -0,0 +1,164 @@
+/**
+ * AdtClient - High-level ADT Object Operations Client
+ *
+ * Provides simplified CRUD operations with automatic operation chains,
+ * error handling, and resource cleanup.
+ *
+ * Unlike CrudClient which provides low-level operations, AdtClient provides
+ * high-level methods that encapsulate complex operation chains:
+ * - Create: validate → create → check → lock → check(inactive) → update → unlock → check → activate
+ * - Update: lock → check(inactive) → update → unlock → check → activate
+ * - Delete: check(deletion) → delete
+ *
+ * Each factory method returns an IAdtObject instance that can be used
+ * to perform operations on a specific object type.
+ */
+import { IAbapConnection, IAdtObject } from '@mcp-abap-adt/interfaces';
+import { IClassConfig, IClassState, ILocalTestClassConfig, ILocalTypesConfig, ILocalDefinitionsConfig, ILocalMacrosConfig } from '../core/class';
+import { IProgramConfig, IProgramState } from '../core/program';
+import { IInterfaceConfig, IInterfaceState } from '../core/interface';
+import { IDomainConfig, IDomainState } from '../core/domain';
+import { IDataElementConfig, IDataElementState } from '../core/dataElement';
+import { IStructureConfig, IStructureState } from '../core/structure';
+import { ITableConfig, ITableState } from '../core/table';
+import { IViewConfig, IViewState } from '../core/view';
+import { IFunctionGroupConfig, IFunctionGroupState } from '../core/functionGroup';
+import { IFunctionModuleConfig, IFunctionModuleState } from '../core/functionModule';
+import { IPackageConfig, IPackageState } from '../core/package';
+import { IServiceDefinitionConfig, IServiceDefinitionState } from '../core/serviceDefinition';
+import { IBehaviorDefinitionConfig, IBehaviorDefinitionState } from '../core/behaviorDefinition';
+import { IBehaviorImplementationConfig, IBehaviorImplementationState } from '../core/behaviorImplementation';
+import { IMetadataExtensionConfig, IMetadataExtensionState } from '../core/metadataExtension';
+import { IUnitTestConfig, IUnitTestState, ICdsUnitTestConfig, ICdsUnitTestState } from '../core/unitTest';
+import { ITransportConfig, ITransportState } from '../core/transport/types';
+import { AdtUtils } from '../core/shared/AdtUtils';
+import type { ILogger } from '@mcp-abap-adt/interfaces';
+export declare class AdtClient {
+    private connection;
+    private logger;
+    constructor(connection: IAbapConnection, logger?: ILogger);
+    /**
+     * Get high-level operations for Class objects
+     * @returns IAdtObject instance for Class operations
+     */
+    getClass(): IAdtObject<IClassConfig, IClassState>;
+    /**
+     * Get high-level operations for Program objects
+     * @returns IAdtObject instance for Program operations
+     */
+    getProgram(): IAdtObject<IProgramConfig, IProgramState>;
+    /**
+     * Get high-level operations for Interface objects
+     * @returns IAdtObject instance for Interface operations
+     */
+    getInterface(): IAdtObject<IInterfaceConfig, IInterfaceState>;
+    /**
+     * Get high-level operations for Domain objects
+     * @returns IAdtObject instance for Domain operations
+     */
+    getDomain(): IAdtObject<IDomainConfig, IDomainState>;
+    /**
+     * Get high-level operations for DataElement objects
+     * @returns IAdtObject instance for DataElement operations
+     */
+    getDataElement(): IAdtObject<IDataElementConfig, IDataElementState>;
+    /**
+     * Get high-level operations for Structure objects
+     * @returns IAdtObject instance for Structure operations
+     */
+    getStructure(): IAdtObject<IStructureConfig, IStructureState>;
+    /**
+     * Get high-level operations for Table objects
+     * @returns IAdtObject instance for Table operations
+     */
+    getTable(): IAdtObject<ITableConfig, ITableState>;
+    /**
+     * Get high-level operations for View objects
+     * @returns IAdtObject instance for View operations
+     */
+    getView(): IAdtObject<IViewConfig, IViewState>;
+    /**
+     * Get high-level operations for FunctionGroup objects
+     * @returns IAdtObject instance for FunctionGroup operations
+     */
+    getFunctionGroup(): IAdtObject<IFunctionGroupConfig, IFunctionGroupState>;
+    /**
+     * Get high-level operations for FunctionModule objects
+     * @returns IAdtObject instance for FunctionModule operations
+     */
+    getFunctionModule(): IAdtObject<IFunctionModuleConfig, IFunctionModuleState>;
+    /**
+     * Get high-level operations for Package objects
+     * @returns IAdtObject instance for Package operations
+     */
+    getPackage(): IAdtObject<IPackageConfig, IPackageState>;
+    /**
+     * Get high-level operations for ServiceDefinition objects
+     * @returns IAdtObject instance for ServiceDefinition operations
+     */
+    getServiceDefinition(): IAdtObject<IServiceDefinitionConfig, IServiceDefinitionState>;
+    /**
+     * Get high-level operations for BehaviorDefinition objects
+     * @returns IAdtObject instance for BehaviorDefinition operations
+     */
+    getBehaviorDefinition(): IAdtObject<IBehaviorDefinitionConfig, IBehaviorDefinitionState>;
+    /**
+     * Get high-level operations for BehaviorImplementation objects
+     * @returns IAdtObject instance for BehaviorImplementation operations
+     */
+    getBehaviorImplementation(): IAdtObject<IBehaviorImplementationConfig, IBehaviorImplementationState>;
+    /**
+     * Get high-level operations for MetadataExtension objects
+     * @returns IAdtObject instance for MetadataExtension operations
+     */
+    getMetadataExtension(): IAdtObject<IMetadataExtensionConfig, IMetadataExtensionState>;
+    /**
+     * Get high-level operations for UnitTest objects
+     * @returns IAdtObject instance for UnitTest operations
+     */
+    getUnitTest(): IAdtObject<IUnitTestConfig, IUnitTestState>;
+    /**
+     * Get high-level operations for CDS UnitTest objects
+     * @returns IAdtObject instance for CDS UnitTest operations (extends AdtUnitTest with CDS-specific methods)
+     */
+    getCdsUnitTest(): IAdtObject<ICdsUnitTestConfig, ICdsUnitTestState>;
+    /**
+     * Get high-level operations for Request (Transport Request) objects
+     * @returns IAdtObject instance for Request operations
+     */
+    getRequest(): IAdtObject<ITransportConfig, ITransportState>;
+    /**
+     * Get utility functions (NOT CRUD operations)
+     * Provides access to cross-cutting ADT utility functions:
+     * - Search operations
+     * - Where-used analysis
+     * - Inactive objects management
+     * - Group activation/deletion
+     * - Object metadata and source code reading
+     * - SQL queries and table contents
+     *
+     * @returns AdtUtils instance for utility operations
+     */
+    getUtils(): AdtUtils;
+    /**
+     * Get high-level operations for LocalTestClass objects
+     * @returns IAdtObject instance for LocalTestClass operations
+     */
+    getLocalTestClass(): IAdtObject<ILocalTestClassConfig, IClassState>;
+    /**
+     * Get high-level operations for LocalTypes objects
+     * @returns IAdtObject instance for LocalTypes operations
+     */
+    getLocalTypes(): IAdtObject<ILocalTypesConfig, IClassState>;
+    /**
+     * Get high-level operations for LocalDefinitions objects
+     * @returns IAdtObject instance for LocalDefinitions operations
+     */
+    getLocalDefinitions(): IAdtObject<ILocalDefinitionsConfig, IClassState>;
+    /**
+     * Get high-level operations for LocalMacros objects
+     * @returns IAdtObject instance for LocalMacros operations
+     */
+    getLocalMacros(): IAdtObject<ILocalMacrosConfig, IClassState>;
+}
+//# sourceMappingURL=AdtClient.d.ts.map

package/dist/clients/AdtClient.d.ts.map

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

package/dist/clients/AdtClient.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * AdtClient - High-level ADT Object Operations Client
+ *
+ * Provides simplified CRUD operations with automatic operation chains,
+ * error handling, and resource cleanup.
+ *
+ * Unlike CrudClient which provides low-level operations, AdtClient provides
+ * high-level methods that encapsulate complex operation chains:
+ * - Create: validate → create → check → lock → check(inactive) → update → unlock → check → activate
+ * - Update: lock → check(inactive) → update → unlock → check → activate
+ * - Delete: check(deletion) → delete
+ *
+ * Each factory method returns an IAdtObject instance that can be used
+ * to perform operations on a specific object type.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdtClient = void 0;
+const class_1 = require("../core/class");
+const program_1 = require("../core/program");
+const interface_1 = require("../core/interface");
+const domain_1 = require("../core/domain");
+const dataElement_1 = require("../core/dataElement");
+const structure_1 = require("../core/structure");
+const table_1 = require("../core/table");
+const view_1 = require("../core/view");
+const functionGroup_1 = require("../core/functionGroup");
+const functionModule_1 = require("../core/functionModule");
+const package_1 = require("../core/package");
+const serviceDefinition_1 = require("../core/serviceDefinition");
+const behaviorDefinition_1 = require("../core/behaviorDefinition");
+const behaviorImplementation_1 = require("../core/behaviorImplementation");
+const metadataExtension_1 = require("../core/metadataExtension");
+const transport_1 = require("../core/transport");
+const unitTest_1 = require("../core/unitTest");
+const AdtUtils_1 = require("../core/shared/AdtUtils");
+class AdtClient {
+    connection;
+    logger;
+    constructor(connection, logger) {
+        this.connection = connection;
+        this.logger = logger ?? {
+            debug: () => { },
+            info: () => { },
+            warn: () => { },
+            error: () => { },
+        };
+    }
+    /**
+     * Get high-level operations for Class objects
+     * @returns IAdtObject instance for Class operations
+     */
+    getClass() {
+        return new class_1.AdtClass(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for Program objects
+     * @returns IAdtObject instance for Program operations
+     */
+    getProgram() {
+        return new program_1.AdtProgram(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for Interface objects
+     * @returns IAdtObject instance for Interface operations
+     */
+    getInterface() {
+        return new interface_1.AdtInterface(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for Domain objects
+     * @returns IAdtObject instance for Domain operations
+     */
+    getDomain() {
+        return new domain_1.AdtDomain(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for DataElement objects
+     * @returns IAdtObject instance for DataElement operations
+     */
+    getDataElement() {
+        return new dataElement_1.AdtDataElement(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for Structure objects
+     * @returns IAdtObject instance for Structure operations
+     */
+    getStructure() {
+        return new structure_1.AdtStructure(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for Table objects
+     * @returns IAdtObject instance for Table operations
+     */
+    getTable() {
+        return new table_1.AdtTable(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for View objects
+     * @returns IAdtObject instance for View operations
+     */
+    getView() {
+        return new view_1.AdtView(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for FunctionGroup objects
+     * @returns IAdtObject instance for FunctionGroup operations
+     */
+    getFunctionGroup() {
+        return new functionGroup_1.AdtFunctionGroup(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for FunctionModule objects
+     * @returns IAdtObject instance for FunctionModule operations
+     */
+    getFunctionModule() {
+        return new functionModule_1.AdtFunctionModule(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for Package objects
+     * @returns IAdtObject instance for Package operations
+     */
+    getPackage() {
+        return new package_1.AdtPackage(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for ServiceDefinition objects
+     * @returns IAdtObject instance for ServiceDefinition operations
+     */
+    getServiceDefinition() {
+        return new serviceDefinition_1.AdtServiceDefinition(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for BehaviorDefinition objects
+     * @returns IAdtObject instance for BehaviorDefinition operations
+     */
+    getBehaviorDefinition() {
+        return new behaviorDefinition_1.AdtBehaviorDefinition(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for BehaviorImplementation objects
+     * @returns IAdtObject instance for BehaviorImplementation operations
+     */
+    getBehaviorImplementation() {
+        return new behaviorImplementation_1.AdtBehaviorImplementation(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for MetadataExtension objects
+     * @returns IAdtObject instance for MetadataExtension operations
+     */
+    getMetadataExtension() {
+        return new metadataExtension_1.AdtMetadataExtension(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for UnitTest objects
+     * @returns IAdtObject instance for UnitTest operations
+     */
+    getUnitTest() {
+        return new unitTest_1.AdtUnitTest(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for CDS UnitTest objects
+     * @returns IAdtObject instance for CDS UnitTest operations (extends AdtUnitTest with CDS-specific methods)
+     */
+    getCdsUnitTest() {
+        return new unitTest_1.AdtCdsUnitTest(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for Request (Transport Request) objects
+     * @returns IAdtObject instance for Request operations
+     */
+    getRequest() {
+        return new transport_1.AdtRequest(this.connection, this.logger);
+    }
+    /**
+     * Get utility functions (NOT CRUD operations)
+     * Provides access to cross-cutting ADT utility functions:
+     * - Search operations
+     * - Where-used analysis
+     * - Inactive objects management
+     * - Group activation/deletion
+     * - Object metadata and source code reading
+     * - SQL queries and table contents
+     *
+     * @returns AdtUtils instance for utility operations
+     */
+    getUtils() {
+        return new AdtUtils_1.AdtUtils(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for LocalTestClass objects
+     * @returns IAdtObject instance for LocalTestClass operations
+     */
+    getLocalTestClass() {
+        return new class_1.AdtLocalTestClass(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for LocalTypes objects
+     * @returns IAdtObject instance for LocalTypes operations
+     */
+    getLocalTypes() {
+        return new class_1.AdtLocalTypes(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for LocalDefinitions objects
+     * @returns IAdtObject instance for LocalDefinitions operations
+     */
+    getLocalDefinitions() {
+        return new class_1.AdtLocalDefinitions(this.connection, this.logger);
+    }
+    /**
+     * Get high-level operations for LocalMacros objects
+     * @returns IAdtObject instance for LocalMacros operations
+     */
+    getLocalMacros() {
+        return new class_1.AdtLocalMacros(this.connection, this.logger);
+    }
+}
+exports.AdtClient = AdtClient;