tm1npm 1.6.0 → 2.0.0

package/src/services/TM1Service.ts

@@ -8,6 +8,19 @@ import { BulkService } from './BulkService';
 import { AsyncOperationService } from './AsyncOperationService';
 import { PowerBiService } from './PowerBiService';
 import { ApplicationService } from './ApplicationService';
+import { AnnotationService } from './AnnotationService';
+import { ChoreService } from './ChoreService';
+import { GitService } from './GitService';
+import { SandboxService } from './SandboxService';
+import { JobService } from './JobService';
+import { UserService } from './UserService';
+import { ThreadService } from './ThreadService';
+import { TransactionLogService } from './TransactionLogService';
+import { MessageLogService } from './MessageLogService';
+import { ConfigurationService } from './ConfigurationService';
+import { AuditLogService } from './AuditLogService';
+import { LoggerService } from './LoggerService';
+import { User } from '../objects/User';
 import {
     CubeService,
     ElementService,
@@ -26,6 +39,19 @@ export class TM1Service {
     private _server?: ServerService;
     private _monitoring?: MonitoringService;
 
+    private _annotations?: AnnotationService;
+    private _chores?: ChoreService;
+    private _git?: GitService;
+    private _sandboxes?: SandboxService;
+    private _jobs?: JobService;
+    private _users?: UserService;
+    private _threads?: ThreadService;
+    private _transactionLogs?: TransactionLogService;
+    private _messageLogs?: MessageLogService;
+    private _configuration?: ConfigurationService;
+    private _auditLogs?: AuditLogService;
+    private _loggers?: LoggerService;
+
     public dimensions: DimensionService;
     public hierarchies: HierarchyService;
     public subsets: SubsetService;
@@ -98,9 +124,92 @@ export class TM1Service {
         return this._monitoring;
     }
 
-    public async whoami(): Promise<string> {
-        const user = await this.security.getCurrentUser();
-        return user.name;
+    public get annotations(): AnnotationService {
+        if (!this._annotations) {
+            this._annotations = new AnnotationService(this._tm1Rest);
+        }
+        return this._annotations;
+    }
+
+    public get chores(): ChoreService {
+        if (!this._chores) {
+            this._chores = new ChoreService(this._tm1Rest);
+        }
+        return this._chores;
+    }
+
+    public get git(): GitService {
+        if (!this._git) {
+            this._git = new GitService(this._tm1Rest);
+        }
+        return this._git;
+    }
+
+    public get sandboxes(): SandboxService {
+        if (!this._sandboxes) {
+            this._sandboxes = new SandboxService(this._tm1Rest);
+        }
+        return this._sandboxes;
+    }
+
+    public get jobs(): JobService {
+        if (!this._jobs) {
+            this._jobs = new JobService(this._tm1Rest);
+        }
+        return this._jobs;
+    }
+
+    public get users(): UserService {
+        if (!this._users) {
+            this._users = new UserService(this._tm1Rest);
+        }
+        return this._users;
+    }
+
+    public get threads(): ThreadService {
+        if (!this._threads) {
+            this._threads = new ThreadService(this._tm1Rest);
+        }
+        return this._threads;
+    }
+
+    public get transactionLogs(): TransactionLogService {
+        if (!this._transactionLogs) {
+            this._transactionLogs = new TransactionLogService(this._tm1Rest);
+        }
+        return this._transactionLogs;
+    }
+
+    public get messageLogs(): MessageLogService {
+        if (!this._messageLogs) {
+            this._messageLogs = new MessageLogService(this._tm1Rest);
+        }
+        return this._messageLogs;
+    }
+
+    public get configuration(): ConfigurationService {
+        if (!this._configuration) {
+            this._configuration = new ConfigurationService(this._tm1Rest);
+        }
+        return this._configuration;
+    }
+
+    public get auditLogs(): AuditLogService {
+        if (!this._auditLogs) {
+            this._auditLogs = new AuditLogService(this._tm1Rest);
+        }
+        return this._auditLogs;
+    }
+
+    public get loggers(): LoggerService {
+        if (!this._loggers) {
+            this._loggers = new LoggerService(this._tm1Rest);
+        }
+        return this._loggers;
+    }
+
+    public async whoami(): Promise<User> {
+        return await this.security.getCurrentUser();
     }
 
     public async getMetadata(): Promise<any> {
@@ -108,9 +217,12 @@ export class TM1Service {
         return response.data;
     }
 
+    public get version(): string | undefined {
+        return this._tm1Rest.version;
+    }
+
     public async getVersion(): Promise<string> {
-        const response = await this._tm1Rest.get('/Configuration/ProductVersion');
-        return response.data.value;
+        return await this._tm1Rest.getVersion();
     }
 
     public get connection(): RestService {
@@ -133,6 +245,12 @@ export class TM1Service {
         return this._tm1Rest.isLoggedIn();
     }
 
+    /** Reconnects without teardown. Use reAuthenticate() for full disconnect+reconnect. */
+    public async reConnect(): Promise<void> {
+        await this._tm1Rest.connect();
+    }
+
+    /** Full teardown + reconnect. If disconnect() throws, connect() is not attempted. */
     public async reAuthenticate(): Promise<void> {
         await this._tm1Rest.disconnect();
         await this._tm1Rest.connect();
@@ -153,4 +271,4 @@ export class TM1Service {
             console.warn(`Logout failed due to exception: ${error}`);
         }
     }
-}
+}

package/src/tests/asyncOperationService.test.ts

@@ -381,8 +381,11 @@ describe('AsyncOperationService', () => {
             });
             asyncService.updateOperationStatus(id3, OperationStatus.COMPLETED);
 
+            // HTTP 202 = still running on the /_async endpoint.
             mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'Running' }
+                status: 202,
+                headers: {},
+                data: {}
             });
 
             const activeOps = await asyncService.listActiveAsyncOperations();
@@ -641,91 +644,92 @@ describe('AsyncOperationService', () => {
         });
     });
 
+    // Status is inferred from the /_async('{id}') HTTP status code and the
+    // v12 `asyncresult` header; there is no `.Status` envelope on the new endpoint.
+    // These tests bypass createAsyncOperation (which tags operations as
+    // trackedLocally: true) to exercise the server-polling branch directly.
     describe('Server Status Mapping', () => {
-        test('should map CompletedSuccessfully to COMPLETED', async () => {
-            const operationId = await asyncService.createAsyncOperation({
+        const injectServerOperation = (id: string) => {
+            (asyncService as any).operations.set(id, {
+                id,
                 type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
+                name: 'TestProcess',
+                status: OperationStatus.RUNNING,
+                startTime: new Date(),
+                trackedLocally: false
             });
+        };
 
-            asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
+        test('should map HTTP 200 without asyncresult header to COMPLETED', async () => {
+            injectServerOperation('srv-1');
 
             mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'CompletedSuccessfully', Result: { value: 42 } }
+                status: 200,
+                headers: {},
+                data: { value: 42 }
             });
 
-            const status = await asyncService.getAsyncOperationStatus(operationId);
+            const status = await asyncService.getAsyncOperationStatus('srv-1');
             expect(status).toBe(OperationStatus.COMPLETED);
 
-            const operation = asyncService.getOperation(operationId);
+            const operation = asyncService.getOperation('srv-1');
             expect(operation?.result).toEqual({ value: 42 });
         });
 
-        test('should map CompletedWithErrors to FAILED', async () => {
-            const operationId = await asyncService.createAsyncOperation({
-                type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
-            });
-
-            asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
+        test('should map HTTP 200 with non-2xx asyncresult header to FAILED', async () => {
+            injectServerOperation('srv-2');
 
             mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'CompletedWithErrors', Error: 'Process failed at line 10' }
+                status: 200,
+                headers: { asyncresult: '500 Internal Server Error' },
+                data: {}
             });
 
-            const status = await asyncService.getAsyncOperationStatus(operationId);
+            const status = await asyncService.getAsyncOperationStatus('srv-2');
             expect(status).toBe(OperationStatus.FAILED);
 
-            const operation = asyncService.getOperation(operationId);
-            expect(operation?.error).toBe('Process failed at line 10');
+            const operation = asyncService.getOperation('srv-2');
+            expect(operation?.error).toBe('500 Internal Server Error');
         });
 
-        test('should map Cancelled status correctly', async () => {
-            const operationId = await asyncService.createAsyncOperation({
-                type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
-            });
+        test('should map thrown TM1RestException to FAILED', async () => {
+            injectServerOperation('srv-3');
 
-            asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
-
-            mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'Cancelled' }
-            });
+            const { TM1RestException } = require('../exceptions/TM1Exception');
+            mockRestService.get = jest.fn().mockRejectedValue(
+                new TM1RestException('Server error', 500)
+            );
 
-            const status = await asyncService.getAsyncOperationStatus(operationId);
-            expect(status).toBe(OperationStatus.CANCELLED);
+            const status = await asyncService.getAsyncOperationStatus('srv-3');
+            expect(status).toBe(OperationStatus.FAILED);
         });
 
-        test('should map Timeout status correctly', async () => {
-            const operationId = await asyncService.createAsyncOperation({
-                type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
-            });
-
-            asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
+        test('should map HTTP 202 to RUNNING', async () => {
+            injectServerOperation('srv-4');
 
             mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'Timeout' }
+                status: 202,
+                headers: {},
+                data: {}
             });
 
-            const status = await asyncService.getAsyncOperationStatus(operationId);
-            expect(status).toBe(OperationStatus.TIMEOUT);
+            const status = await asyncService.getAsyncOperationStatus('srv-4');
+            expect(status).toBe(OperationStatus.RUNNING);
         });
 
-        test('should default to PENDING for unknown status', async () => {
+        test('locally-tracked operations skip server polling and return cached status', async () => {
             const operationId = await asyncService.createAsyncOperation({
                 type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
+                name: 'LocalProcess'
             });
-
             asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
 
-            mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'UnknownStatus' }
-            });
+            const getSpy = jest.fn();
+            mockRestService.get = getSpy;
 
             const status = await asyncService.getAsyncOperationStatus(operationId);
-            expect(status).toBe(OperationStatus.PENDING);
+            expect(status).toBe(OperationStatus.RUNNING);
+            expect(getSpy).not.toHaveBeenCalled();
         });
     });
 

package/src/tests/processService.comprehensive.test.ts

@@ -307,7 +307,7 @@ describe('ProcessService - Comprehensive Tests', () => {
             expect(mockRestService.post).toHaveBeenCalledWith(
                 "/Processes('TestProcess')/tm1.ExecuteWithReturn?$expand=*",
                 "{}",
-                { timeout: 30000 }
+                { timeout: 30 }
             );
         });
 
@@ -940,7 +940,7 @@ describe('ProcessService - Comprehensive Tests', () => {
             expect(mockRestService.post).toHaveBeenCalledWith(
                 expect.any(String),
                 expect.any(String),
-                { timeout: 60000 }
+                { timeout: 60 }
             );
         });
 
@@ -1244,4 +1244,4 @@ describe('ProcessService - Comprehensive Tests', () => {
             expect(mockRestService.get).toHaveBeenCalledTimes(3);
         });
     });
-});
+});

package/src/tests/processService.test.ts

@@ -459,9 +459,16 @@ describe('ProcessService Tests', () => {
 
     describe('Process Async Polling', () => {
         test('pollExecuteWithReturn should return parsed result on success', async () => {
+            // retrieve_async_response returns an AxiosResponse; the execute summary
+            // lives in .data. Tests that mocked the raw body directly did not
+            // reflect production shape and silently passed against the untyped
+            // parser signature.
             (mockRestService as any).retrieve_async_response = jest.fn().mockResolvedValue({
-                ProcessExecuteStatusCode: 'CompletedSuccessfully',
-                ErrorLogFile: null
+                status: 200,
+                data: {
+                    ProcessExecuteStatusCode: 'CompletedSuccessfully',
+                    ErrorLogFile: null
+                }
             });
 
             const result = await processService.pollExecuteWithReturn('async-001');
@@ -472,8 +479,11 @@ describe('ProcessService Tests', () => {
 
         test('pollExecuteWithReturn should return error log file when present', async () => {
             (mockRestService as any).retrieve_async_response = jest.fn().mockResolvedValue({
-                ProcessExecuteStatusCode: 'CompletedWithMessages',
-                ErrorLogFile: { Filename: 'TM1ProcessError_20240101.log' }
+                status: 200,
+                data: {
+                    ProcessExecuteStatusCode: 'CompletedWithMessages',
+                    ErrorLogFile: { Filename: 'TM1ProcessError_20240101.log' }
+                }
             });
 
             const result = await processService.pollExecuteWithReturn('async-002');
@@ -493,10 +503,12 @@ describe('ProcessService Tests', () => {
         });
 
         test('pollExecuteWithReturn should return null for 202 (accepted/pending)', async () => {
-            const { TM1RestException } = require('../exceptions/TM1Exception');
-            (mockRestService as any).retrieve_async_response = jest.fn().mockRejectedValue(
-                new TM1RestException('Accepted', 202)
-            );
+            // After the #80 refactor retrieve_async_response returns the raw AxiosResponse
+            // instead of throwing on 202; the pending path is now signalled by status === 202.
+            (mockRestService as any).retrieve_async_response = jest.fn().mockResolvedValue({
+                status: 202,
+                data: {}
+            });
 
             const result = await processService.pollExecuteWithReturn('async-004');
 
@@ -685,4 +697,4 @@ describe('ProcessService Tests', () => {
             expect(mockRestService.delete).toHaveBeenCalled();
         });
     });
-});
+});