tm1npm 1.6.0 → 2.0.0

package/lib/tests/tm1Service.test.js

@@ -7,6 +7,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const TM1Service_1 = require("../services/TM1Service");
 const RestService_1 = require("../services/RestService");
+const User_1 = require("../objects/User");
 // Mock all service dependencies
 jest.mock('../services/RestService');
 jest.mock('../services/DimensionService');
@@ -22,6 +23,19 @@ jest.mock('../services/FileService');
 jest.mock('../services/SessionService');
 jest.mock('../services/ServerService');
 jest.mock('../services/MonitoringService');
+jest.mock('../services/AnnotationService');
+jest.mock('../services/ChoreService');
+jest.mock('../services/GitService');
+jest.mock('../services/ApplicationService');
+jest.mock('../services/SandboxService');
+jest.mock('../services/JobService');
+jest.mock('../services/UserService');
+jest.mock('../services/ThreadService');
+jest.mock('../services/TransactionLogService');
+jest.mock('../services/MessageLogService');
+jest.mock('../services/ConfigurationService');
+jest.mock('../services/AuditLogService');
+jest.mock('../services/LoggerService');
 describe('TM1Service', () => {
     let tm1Service;
     let mockRestService;
@@ -56,6 +70,8 @@ describe('TM1Service', () => {
             setSandbox: jest.fn(),
             getSandbox: jest.fn().mockReturnValue('test-sandbox'),
             isLoggedIn: jest.fn().mockReturnValue(true),
+            getVersion: jest.fn().mockResolvedValue('12.0.0'),
+            version: undefined,
         };
         // Mock RestService constructor
         RestService_1.RestService.mockImplementation(() => mockRestService);
@@ -75,6 +91,7 @@ describe('TM1Service', () => {
             expect(tm1Service.security).toBeDefined();
             expect(tm1Service.files).toBeDefined();
             expect(tm1Service.sessions).toBeDefined();
+            expect(tm1Service.applications).toBeDefined();
         });
         test('should create RestService with provided config', () => {
             expect(RestService_1.RestService).toHaveBeenCalledWith(mockConfig);
@@ -123,14 +140,16 @@ describe('TM1Service', () => {
         });
     });
     describe('User and Authentication', () => {
-        test('should get current user with whoami', async () => {
-            // Mock security service getCurrentUser method
+        test('should get current user as User object with whoami', async () => {
+            const expectedUser = new User_1.User('test-user', ['ADMIN'], 'Test User', undefined, User_1.UserType.Admin, true);
             const mockSecurityService = {
-                getCurrentUser: jest.fn().mockResolvedValue({ name: 'test-user' })
+                getCurrentUser: jest.fn().mockResolvedValue(expectedUser)
             };
             tm1Service.security = mockSecurityService;
             const result = await tm1Service.whoami();
-            expect(result).toBe('test-user');
+            expect(result).toBeInstanceOf(User_1.User);
+            expect(result.name).toBe('test-user');
+            expect(result).toBe(expectedUser);
             expect(mockSecurityService.getCurrentUser).toHaveBeenCalledTimes(1);
         });
         test('should check if user is logged in', () => {
@@ -157,11 +176,11 @@ describe('TM1Service', () => {
             expect(result).toEqual({ metadata: 'test-metadata' });
             expect(mockRestService.get).toHaveBeenCalledWith('/$metadata');
         });
-        test('should get TM1 version', async () => {
-            mockRestService.get.mockResolvedValueOnce(mockResponse({ value: '12.0.0' }));
+        test('should get TM1 version via cached RestService.getVersion', async () => {
+            mockRestService.getVersion.mockResolvedValueOnce('12.0.0');
             const result = await tm1Service.getVersion();
             expect(result).toBe('12.0.0');
-            expect(mockRestService.get).toHaveBeenCalledWith('/Configuration/ProductVersion');
+            expect(mockRestService.getVersion).toHaveBeenCalledTimes(1);
         });
         test('should handle metadata retrieval errors', async () => {
             const metadataError = new Error('Metadata not available');
@@ -170,7 +189,7 @@ describe('TM1Service', () => {
         });
         test('should handle version retrieval errors', async () => {
             const versionError = new Error('Version not available');
-            mockRestService.get.mockRejectedValueOnce(versionError);
+            mockRestService.getVersion.mockRejectedValueOnce(versionError);
             await expect(tm1Service.getVersion()).rejects.toThrow('Version not available');
         });
     });
@@ -286,5 +305,58 @@ describe('TM1Service', () => {
             expect(monitoring1).toBe(monitoring2);
         });
     });
+    describe('Lazy Services (Issue #82)', () => {
+        const lazyServiceNames = [
+            'annotations',
+            'chores',
+            'git',
+            'sandboxes',
+            'jobs',
+            'users',
+            'threads',
+            'transactionLogs',
+            'messageLogs',
+            'configuration',
+            'auditLogs',
+            'loggers',
+        ];
+        test.each(lazyServiceNames)('should lazy-initialize %s service', (serviceName) => {
+            const instance = tm1Service[serviceName];
+            expect(instance).toBeDefined();
+        });
+        test.each(lazyServiceNames)('should cache %s service instance across accesses', (serviceName) => {
+            const first = tm1Service[serviceName];
+            const second = tm1Service[serviceName];
+            expect(second).toBe(first);
+        });
+    });
+    describe('Version Getter (Issue #82)', () => {
+        test('should expose cached version via sync getter', () => {
+            Object.defineProperty(mockRestService, 'version', {
+                get: () => '11.8.0',
+                configurable: true,
+            });
+            expect(tm1Service.version).toBe('11.8.0');
+        });
+        test('should return undefined when version has not been fetched yet', () => {
+            Object.defineProperty(mockRestService, 'version', {
+                get: () => undefined,
+                configurable: true,
+            });
+            expect(tm1Service.version).toBeUndefined();
+        });
+    });
+    describe('reConnect (Issue #82)', () => {
+        test('should call connect without disconnecting (tm1py parity)', async () => {
+            await tm1Service.reConnect();
+            expect(mockRestService.connect).toHaveBeenCalledTimes(1);
+            expect(mockRestService.disconnect).not.toHaveBeenCalled();
+        });
+        test('should propagate errors from connect', async () => {
+            mockRestService.connect.mockRejectedValueOnce(new Error('Connect failed'));
+            await expect(tm1Service.reConnect()).rejects.toThrow('Connect failed');
+            expect(mockRestService.connect).toHaveBeenCalledTimes(1);
+        });
+    });
 });
 //# sourceMappingURL=tm1Service.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tm1npm",
-  "version": "1.6.0",
+  "version": "2.0.0",
   "description": "A Node.js module for TM1",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/services/ApplicationService.ts

@@ -1,4 +1,4 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { AxiosResponse } from 'axios';
 import { promises as fs } from 'fs';
 import { RestService } from './RestService';
 import { ObjectService } from './ObjectService';
@@ -152,7 +152,7 @@ export class ApplicationService extends ObjectService {
             requestName
         );
 
-        const arrayBufferResponse = await this.rest.get(contentUrl, { responseType: 'arraybuffer' } as AxiosRequestConfig);
+        const arrayBufferResponse = await this.rest.get(contentUrl, { responseType: 'arraybuffer' });
         const metadataResponse = await this.rest.get(metadataUrl);
 
         const buffer = Buffer.from(arrayBufferResponse.data);
@@ -183,7 +183,7 @@ export class ApplicationService extends ObjectService {
             );
             await this.rest.put(contentUrl, application.content, {
                 headers: this.binaryHttpHeader
-            } as AxiosRequestConfig);
+            });
         }
 
         return response;
@@ -204,7 +204,7 @@ export class ApplicationService extends ObjectService {
             );
             return await this.rest.post(url, application.content, {
                 headers: this.binaryHttpHeader
-            } as AxiosRequestConfig);
+            });
         }
 
         const url = formatUrl(

package/src/services/AsyncOperationService.ts

@@ -52,6 +52,12 @@ export interface AsyncOperation {
     result?: any;
     parameters?: Record<string, any>;
     metadata?: Record<string, any>;
+    /**
+     * When true, the operation is tracked with a client-side UUID and the
+     * TM1 server has no record of it. `getAsyncOperationStatus` returns the
+     * cached status instead of polling `/_async('{id}')`.
+     */
+    trackedLocally?: boolean;
 }
 
 /**
@@ -113,30 +119,81 @@ export class AsyncOperationService {
             return operation.status;
         }
 
-        // Poll TM1 server for updated status
+        // Locally tracked operations hold a client-side UUID; the TM1 server
+        // would return 404 for them. Rely on the in-memory cache, which is
+        // populated by background .then()/.catch() callbacks in helpers like
+        // ProcessService.executeWithReturnAsync.
+        if (operation.trackedLocally) {
+            return operation.status;
+        }
+
+        // Poll TM1 server for updated status. /_async('{id}') returns 202 while
+        // the op is pending, and 200/201 with the final operation payload once done.
+        // TM1 v12 may encode embedded failures in the `asyncresult` response header.
         try {
-            const url = formatUrl("/AsyncOperations('{}')", operationId);
-            const response = await this.rest.get(url);
-            const serverStatus = this.mapServerStatus(response.data.Status);
+            const url = formatUrl("/_async('{}')", operationId);
+            const response = await this.rest.get(url, { asyncRequestsMode: false });
+            const serverStatus = this.deriveStatusFromResponse(response);
 
-            // Update operation status
             operation.status = serverStatus;
             if (this.isTerminalStatus(serverStatus)) {
                 operation.endTime = new Date();
-                if (serverStatus === OperationStatus.COMPLETED && response.data.Result) {
-                    operation.result = response.data.Result;
-                } else if (serverStatus === OperationStatus.FAILED && response.data.Error) {
-                    operation.error = response.data.Error;
+                if (serverStatus === OperationStatus.COMPLETED) {
+                    operation.result = response.data;
+                } else if (serverStatus === OperationStatus.FAILED) {
+                    operation.error = this.extractErrorFromResponse(response);
                 }
             }
 
             return serverStatus;
-        } catch (error) {
-            // If server doesn't support AsyncOperations endpoint, return cached status
+        } catch (error: any) {
+            // HTTP 4xx/5xx surfaces as a thrown TM1RestException — treat as a terminal FAILED
+            // so callers stop polling. Network errors (no status) leave cached status intact.
+            // Note: 404 is treated as FAILED here (operation never materialized). This differs
+            // from ProcessService.pollExecuteWithReturn which treats 404 as "not ready yet"
+            // because process async IDs can take a moment to register on the server.
+            const status = error?.status ?? error?.response?.status;
+            if (typeof status === 'number' && status >= 400) {
+                operation.status = OperationStatus.FAILED;
+                operation.endTime = new Date();
+                operation.error = error?.message ?? String(error);
+                return OperationStatus.FAILED;
+            }
             return operation.status;
         }
     }
 
+    private deriveStatusFromResponse(response: any): OperationStatus {
+        if (response.status === 202) {
+            return OperationStatus.RUNNING;
+        }
+        const asyncResult = response.headers?.['asyncresult'];
+        if (typeof asyncResult === 'string') {
+            const embedded = parseInt(asyncResult.trim().split(/\s+/)[0], 10);
+            if (!Number.isNaN(embedded) && (embedded < 200 || embedded >= 300)) {
+                return OperationStatus.FAILED;
+            }
+        }
+        if (response.status === 200 || response.status === 201) {
+            return OperationStatus.COMPLETED;
+        }
+        return OperationStatus.PENDING;
+    }
+
+    private extractErrorFromResponse(response: any): string {
+        const asyncResult = response.headers?.['asyncresult'];
+        if (typeof asyncResult === 'string') {
+            return asyncResult;
+        }
+        if (typeof response.data === 'string') {
+            return response.data;
+        }
+        if (response.data?.error?.message) {
+            return response.data.error.message;
+        }
+        return JSON.stringify(response.data);
+    }
+
     /**
      * List all active async operations
      *
@@ -178,11 +235,10 @@ export class AsyncOperationService {
         this.stopPolling(operationId);
 
         try {
-            // Try to cancel on server if supported
-            const url = formatUrl("/AsyncOperations('{}')/Cancel", operationId);
-            await this.rest.post(url, {});
+            const url = formatUrl("/_async('{}')", operationId);
+            await this.rest.delete(url, { asyncRequestsMode: false });
         } catch (error) {
-            // If server doesn't support cancellation, just mark as cancelled locally
+            console.warn(`Failed to cancel async operation ${operationId} on server:`, error);
         }
 
         // Update operation status
@@ -243,6 +299,9 @@ export class AsyncOperationService {
     public async createAsyncOperation(definition: AsyncOperationDefinition): Promise<string> {
         const operationId = this.generateOperationId();
 
+        // generateOperationId produces a client-side UUID; the server has no
+        // record of it, so polling /_async('{id}') would 404. Mark as locally
+        // tracked so getAsyncOperationStatus returns the cached status instead.
         const operation: AsyncOperation = {
             id: operationId,
             type: definition.type,
@@ -250,7 +309,8 @@ export class AsyncOperationService {
             status: OperationStatus.PENDING,
             startTime: new Date(),
             parameters: definition.parameters,
-            metadata: definition.metadata
+            metadata: definition.metadata,
+            trackedLocally: true
         };
 
         this.operations.set(operationId, operation);
@@ -442,19 +502,6 @@ export class AsyncOperationService {
                status === OperationStatus.TIMEOUT;
     }
 
-    private mapServerStatus(serverStatus: string): OperationStatus {
-        const statusMap: Record<string, OperationStatus> = {
-            'Pending': OperationStatus.PENDING,
-            'Running': OperationStatus.RUNNING,
-            'CompletedSuccessfully': OperationStatus.COMPLETED,
-            'CompletedWithErrors': OperationStatus.FAILED,
-            'Cancelled': OperationStatus.CANCELLED,
-            'Timeout': OperationStatus.TIMEOUT
-        };
-
-        return statusMap[serverStatus] || OperationStatus.PENDING;
-    }
-
     private stopPolling(operationId: string): void {
         const intervalId = this.pollingIntervals.get(operationId);
         if (intervalId) {

package/src/services/FileService.ts

@@ -1,6 +1,6 @@
 import path from 'path';
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { RestService } from './RestService';
+import { AxiosResponse } from 'axios';
+import { RequestOptions, RestService } from './RestService';
 import { ObjectService } from './ObjectService';
 import { verifyVersion } from '../utils/Utils';
 
@@ -227,7 +227,7 @@ export class FileService extends ObjectService {
     }
 
     private async uploadFileContentWithoutMpu(url: string, content: Buffer): Promise<AxiosResponse> {
-        const config: AxiosRequestConfig = {
+        const config: RequestOptions = {
             headers: this.binaryHttpHeader
         };
         return await this.rest.put(url, content, config);

package/src/services/ProcessService.ts

@@ -1,6 +1,6 @@
 import { AxiosResponse } from 'axios';
 import { v4 as uuidv4 } from 'uuid';
-import { RestService } from './RestService';
+import { RequestOptions, RestService } from './RestService';
 import { ObjectService } from './ObjectService';
 import { Process } from '../objects/Process';
 import { ProcessDebugBreakpoint, BreakPointType, HitMode } from '../objects/ProcessDebugBreakpoint';
@@ -13,6 +13,26 @@ export interface CompileSyntaxError {
     Message: string;
 }
 
+interface ProcessExecuteBody {
+    Parameters?: Array<{ Name: string; Value: unknown }>;
+}
+
+interface ProcessExecuteSummary {
+    ProcessExecuteStatusCode: string;
+    ErrorLogFile?: { Filename?: string } | null;
+}
+
+interface ValidationError {
+    line: number;
+    message: string;
+    severity: string;
+}
+
+interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+}
+
 export class ProcessService extends ObjectService {
     /** Service to handle Object Updates for TI Processes
      * 
@@ -79,7 +99,7 @@ export class ProcessService extends ObjectService {
 
         const response = await this.rest.get(url);
         const responseAsDict = response.data;
-        return responseAsDict.value.map((p: any) => Process.fromDict(p));
+        return responseAsDict.value.map((p: Record<string, unknown>) => Process.fromDict(p));
     }
 
     public async getAllNames(skipControlProcesses: boolean = false): Promise<string[]> {
@@ -93,7 +113,7 @@ export class ProcessService extends ObjectService {
         const url = "/Processes?$select=Name" + (skipControlProcesses ? modelProcessFilter : "");
 
         const response = await this.rest.get(url);
-        const processes = response.data.value.map((process: any) => process.Name);
+        const processes = response.data.value.map((process: { Name: string }) => process.Name);
         return processes;
     }
 
@@ -174,8 +194,8 @@ export class ProcessService extends ObjectService {
          * :return: response
          */
         const url = formatUrl("/Processes('{}')/tm1.Execute", processName);
-        
-        const body: any = {};
+
+        const body: ProcessExecuteBody = {};
         if (parameters && Object.keys(parameters).length > 0) {
             body.Parameters = Object.entries(parameters).map(([name, value]) => ({
                 Name: name,
@@ -199,8 +219,8 @@ export class ProcessService extends ObjectService {
          * :return: response including execution details
          */
         const url = formatUrl("/Processes('{}')/tm1.ExecuteWithReturn?$expand=*", processName);
-        
-        const body: any = {};
+
+        const body: ProcessExecuteBody = {};
         if (parameters && Object.keys(parameters).length > 0) {
             body.Parameters = Object.entries(parameters).map(([name, value]) => ({
                 Name: name,
@@ -208,9 +228,9 @@ export class ProcessService extends ObjectService {
             }));
         }
 
-        const config: any = {};
+        const config: RequestOptions = {};
         if (timeout) {
-            config.timeout = timeout * 1000;
+            config.timeout = timeout;
         }
 
         return await this.rest.post(url, JSON.stringify(body), config);
@@ -247,12 +267,20 @@ export class ProcessService extends ObjectService {
     public async pollExecuteWithReturn(asyncId: string): Promise<[boolean, string, string | null] | null> {
         try {
             const response = await this.rest.retrieve_async_response(asyncId);
+            // tm1py returns None while the async op is still in-flight (status 202).
+            if (response.status !== 200 && response.status !== 201) {
+                return null;
+            }
             // TODO: tm1py handles TM1 < v11 binary-wrapped responses via
             // build_response_from_binary_response. Add support if needed.
-            return this._executeWithReturnParseResponse(response);
-        } catch (error: any) {
-            // Return null for HTTP 202 (accepted/pending) or 404 (not found yet)
-            const status = error?.status ?? error?.response?.status;
+            return this._executeWithReturnParseResponse(response.data);
+        } catch (error) {
+            // 404 means the async resource hasn't materialized yet — return null
+            // so the caller can retry. 202 means still running. Both are
+            // retryable, unlike AsyncOperationService which treats 404 as
+            // terminal FAILED for locally-tracked operations.
+            const err = error as { status?: number; response?: { status?: number } };
+            const status = err?.status ?? err?.response?.status;
             if (status === 202 || status === 404) {
                 return null;
             }
@@ -260,7 +288,7 @@ export class ProcessService extends ObjectService {
         }
     }
 
-    private _executeWithReturnParseResponse(executionSummary: any): [boolean, string, string | null] {
+    private _executeWithReturnParseResponse(executionSummary: ProcessExecuteSummary): [boolean, string, string | null] {
         const success = executionSummary.ProcessExecuteStatusCode === 'CompletedSuccessfully';
         const status = executionSummary.ProcessExecuteStatusCode;
         const errorLogFile = executionSummary.ErrorLogFile?.Filename ?? null;
@@ -300,7 +328,7 @@ export class ProcessService extends ObjectService {
          */
         const url = formatUrl("/ProcessDebugContexts('{}')/Breakpoints", debugId);
         const response = await this.rest.get(url);
-        return response.data.value.map((bp: any) => ProcessDebugBreakpoint.fromDict(bp));
+        return response.data.value.map((bp: Record<string, unknown>) => ProcessDebugBreakpoint.fromDict(bp));
     }
 
     public async debugAddBreakpoint(
@@ -532,7 +560,7 @@ export class ProcessService extends ObjectService {
         }
 
         const response = await this.rest.get(url);
-        return response.data.value.map((log: any) => log.Filename);
+        return response.data.value.map((log: { Filename: string }) => log.Filename);
     }
 
     public async getErrorLogFilenames(
@@ -619,7 +647,7 @@ export class ProcessService extends ObjectService {
         }
 
         const response = await this.rest.get(url);
-        return response.data.value.map((process: any) => process.Name);
+        return response.data.value.map((process: { Name: string }) => process.Name);
     }
 
     public async updateOrCreate(process: Process): Promise<AxiosResponse> {
@@ -673,7 +701,7 @@ export class ProcessService extends ObjectService {
             processName
         );
 
-        const body: any = {};
+        const body: ProcessExecuteBody = {};
         if (parameters && Object.keys(parameters).length > 0) {
             body.Parameters = Object.entries(parameters).map(([name, value]) => ({
                 Name: name,
@@ -681,12 +709,14 @@ export class ProcessService extends ObjectService {
             }));
         }
 
-        const config: any = {};
+        const config: RequestOptions = {};
         if (timeout) {
-            config.timeout = timeout * 1000;
+            config.timeout = timeout;
         }
 
-        const response = await this.rest.post(url, JSON.stringify(body), config);
+        // rest.post returns AxiosResponse | string (string only when caller
+        // opts into returnAsyncId). debugProcess never does, so narrow.
+        const response = (await this.rest.post(url, JSON.stringify(body), config)) as AxiosResponse;
         return response.data;
     }
 
@@ -885,8 +915,8 @@ export class ProcessService extends ObjectService {
      * @example
      * ```typescript
      * const deps = await processService.analyzeProcessDependencies('ImportData');
-     * console.log('Cubes used:', deps.cubes);
-     * console.log('Dimensions used:', deps.dimensions);
+     * // deps.cubes      => array of cube names referenced in the process
+     * // deps.dimensions => array of dimension names referenced in the process
      * ```
      */
     public async analyzeProcessDependencies(processName: string): Promise<any> {
@@ -954,17 +984,17 @@ export class ProcessService extends ObjectService {
      * Validate process syntax without executing it
      *
      * @param processName - Name of the process
-     * @returns Promise<{isValid: boolean, errors: any[]}> - Validation result
+     * @returns Promise<ValidationResult> - Validation result
      *
      * @example
      * ```typescript
      * const result = await processService.validateProcessSyntax('MyProcess');
      * if (!result.isValid) {
-     *     console.error('Errors:', result.errors);
+     *     // result.errors contains ValidationError[] entries
      * }
      * ```
      */
-    public async validateProcessSyntax(processName: string): Promise<{isValid: boolean, errors: any[]}> {
+    public async validateProcessSyntax(processName: string): Promise<ValidationResult> {
         try {
             const response = await this.compile(processName);
             if (response.status === 200) {
@@ -974,8 +1004,9 @@ export class ProcessService extends ObjectService {
                 isValid: false,
                 errors: [{ line: 0, message: response.statusText || 'Compilation failed', severity: 'Error' }]
             };
-        } catch (error: any) {
-            const errorMessage = error.response?.data?.error?.message || error.message || 'Validation failed';
+        } catch (error) {
+            const err = error as { response?: { data?: { error?: { message?: string } } }; message?: string };
+            const errorMessage = err.response?.data?.error?.message || err.message || 'Validation failed';
             return {
                 isValid: false,
                 errors: [{ line: 0, message: errorMessage, severity: 'Error' }]
@@ -992,7 +1023,7 @@ export class ProcessService extends ObjectService {
      * @example
      * ```typescript
      * const plan = await processService.getProcessExecutionPlan('ImportData');
-     * console.log('Estimated execution time:', plan.estimatedTime);
+     * // plan.estimatedTime => estimated execution time (ms)
      * ```
      */
     public async getProcessExecutionPlan(processName: string): Promise<any> {
@@ -1072,19 +1103,20 @@ export class ProcessService extends ObjectService {
 
         // Execute process asynchronously
         this.executeWithReturn(processName, parameters)
-            .then((result: any) => {
+            .then((result: unknown) => {
                 asyncOps.updateOperationStatus(
                     operationId,
                     OperationStatus.COMPLETED,
                     result
                 );
             })
-            .catch((error: any) => {
+            .catch((error: unknown) => {
+                const message = (error as { message?: string })?.message ?? String(error);
                 asyncOps.updateOperationStatus(
                     operationId,
                     OperationStatus.FAILED,
                     undefined,
-                    error.message || String(error)
+                    message
                 );
             });
 
@@ -1100,9 +1132,7 @@ export class ProcessService extends ObjectService {
      * @example
      * ```typescript
      * const status = await processService.pollProcessExecution(operationId);
-     * if (status === OperationStatus.COMPLETED) {
-     *     console.log('Process completed!');
-     * }
+     * // if (status === OperationStatus.COMPLETED) handle completion
      * ```
      */
     public async pollProcessExecution(operationId: string): Promise<OperationStatus> {
@@ -1123,7 +1153,7 @@ export class ProcessService extends ObjectService {
      * @example
      * ```typescript
      * await processService.cancelProcessExecution(operationId);
-     * console.log('Process execution cancelled');
+     * // cancellation is acknowledged once the promise resolves
      * ```
      */
     public async cancelProcessExecution(operationId: string): Promise<void> {
@@ -1134,4 +1164,4 @@ export class ProcessService extends ObjectService {
 
         await asyncOps.cancelAsyncOperation(operationId);
     }
-}
+}