tm1npm 1.5.3 → 2.0.0

package/src/services/SubsetService.ts

@@ -2,8 +2,10 @@ import { AxiosResponse } from 'axios';
 import { RestService } from './RestService';
 import { ObjectService } from './ObjectService';
 import { Subset } from '../objects/Subset';
+import { Element } from '../objects/Element';
 import { ElementService } from './ElementService';
 import { TM1RestException } from '../exceptions/TM1Exception';
+import { formatUrl } from '../utils/Utils';
 
 export class SubsetService extends ObjectService {
     private elementService?: ElementService;
@@ -257,6 +259,52 @@ export class SubsetService extends ObjectService {
         );
     }
 
+    public async updateStaticElements(
+        subsetOrName: Subset | string,
+        dimensionName?: string,
+        hierarchyName?: string,
+        isPrivate: boolean = false,
+        elements?: Array<string | Element>
+    ): Promise<AxiosResponse> {
+        let subsetName: string;
+        let dimName: string;
+        let hierName: string;
+        let elementNames: string[];
+
+        if (subsetOrName instanceof Subset) {
+            const subset = subsetOrName;
+            subsetName = subset.name;
+            dimName = dimensionName || subset.dimensionName;
+            hierName = hierarchyName || subset.hierarchyName;
+            elementNames = elements
+                ? elements.map(e => typeof e === 'string' ? e : e.name)
+                : subset.elements;
+        } else {
+            if (!dimensionName) {
+                throw new Error('dimensionName is required when passing subset name as string');
+            }
+            subsetName = subsetOrName;
+            dimName = dimensionName;
+            hierName = hierarchyName || dimName;
+            elementNames = (elements || []).map(e => typeof e === 'string' ? e : e.name);
+        }
+
+        const subsetsCollection = this.getSubsetCollection(isPrivate);
+        const url = this.formatUrl(
+            "/Dimensions('{}')/Hierarchies('{}')/{}('{}')/Elements/$ref",
+            dimName, hierName, subsetsCollection, subsetName);
+
+        const body = {
+            value: elementNames.map(elementName => ({
+                '@odata.id': formatUrl(
+                    "Dimensions('{}')/Hierarchies('{}')/Elements('{}')",
+                    dimName, hierName, elementName)
+            }))
+        };
+
+        return await this.rest.put(url, JSON.stringify(body));
+    }
+
     private async updateSubsetInstance(subset: Subset, isPrivate: boolean): Promise<AxiosResponse> {
         if (subset.isStatic) {
             await this.deleteElementsFromStaticSubset(

package/src/services/TM1Service.ts

@@ -7,6 +7,20 @@ import { DebuggerService } from './DebuggerService';
 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,
@@ -25,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;
@@ -41,6 +68,7 @@ export class TM1Service {
     public bulk: BulkService;
     public asyncOperations: AsyncOperationService;
     public powerbi: PowerBiService;
+    public applications: ApplicationService;
 
     constructor(config: RestServiceConfig) {
         this._tm1Rest = new RestService(config);
@@ -67,6 +95,7 @@ export class TM1Service {
         this.debugger = new DebuggerService(this._tm1Rest);
         this.bulk = new BulkService(this._tm1Rest, this.cells, this.views);
         this.powerbi = new PowerBiService(this._tm1Rest);
+        this.applications = new ApplicationService(this._tm1Rest);
     }
 
     public async connect(): Promise<void> {
@@ -95,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> {
@@ -105,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 {
@@ -130,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();
@@ -150,4 +271,4 @@ export class TM1Service {
             console.warn(`Logout failed due to exception: ${error}`);
         }
     }
-}
+}

package/src/services/index.ts

@@ -2,7 +2,7 @@
 export { CubeService } from './CubeService';
 export { ElementService } from './ElementService';
 export { CellService } from './CellService';
-export { ProcessService } from './ProcessService';
+export { ProcessService, CompileSyntaxError } from './ProcessService';
 export { ViewService } from './ViewService';
 export { SecurityService } from './SecurityService';
 export { FileService } from './FileService';

package/src/tests/100PercentParityCheck.test.ts

@@ -65,15 +65,30 @@ describe('100% TM1py Parity Function Existence', () => {
         });
     });
 
-    describe('ProcessService - Debug Operations (5 functions)', () => {
-        test('All new ProcessService functions should exist', () => {
+    describe('ProcessService - Debug Operations & Parity (11 functions)', () => {
+        test('All ProcessService debug and parity functions should exist', () => {
+            // Debug step/continue (from #33)
             expect(typeof processService.debugStepOver).toBe('function');
             expect(typeof processService.debugStepIn).toBe('function');
             expect(typeof processService.debugStepOut).toBe('function');
             expect(typeof processService.debugContinue).toBe('function');
             expect(typeof processService.evaluateBooleanTiExpression).toBe('function');
 
-            console.log('✅ All 5 ProcessService functions exist');
+            // Debug breakpoint methods — renamed for tm1py parity (#36)
+            expect(typeof processService.debugGetBreakpoints).toBe('function');
+            expect(typeof processService.debugAddBreakpoint).toBe('function');
+            expect(typeof processService.debugRemoveBreakpoint).toBe('function');
+
+            // Async polling — rewritten for tm1py parity (#36)
+            expect(typeof processService.pollExecuteWithReturn).toBe('function');
+
+            // Unbound process compile (#36)
+            expect(typeof processService.compileProcess).toBe('function');
+
+            // TI expression evaluation (#36)
+            expect(typeof processService.evaluateTiExpression).toBe('function');
+
+            console.log('✅ All 11 ProcessService functions exist');
         });
     });
 
@@ -96,11 +111,11 @@ describe('100% TM1py Parity Function Existence', () => {
     });
 
     describe('100% Parity Achievement Summary', () => {
-        test('should confirm all 22 functions are implemented', () => {
+        test('should confirm all 28 functions are implemented', () => {
             const implementedFunctions = {
                 ElementService: [
                     'deleteElementsUseTi',
-                    'deleteEdgesUseBlob', 
+                    'deleteEdgesUseBlob',
                     'getElementsByLevel',
                     'getElementsFilteredByWildcard',
                     'getAttributeOfElements',
@@ -119,9 +134,15 @@ describe('100% TM1py Parity Function Existence', () => {
                 ProcessService: [
                     'debugStepOver',
                     'debugStepIn',
-                    'debugStepOut', 
+                    'debugStepOut',
                     'debugContinue',
-                    'evaluateBooleanTiExpression'
+                    'evaluateBooleanTiExpression',
+                    'debugGetBreakpoints',
+                    'debugAddBreakpoint',
+                    'debugRemoveBreakpoint',
+                    'pollExecuteWithReturn',
+                    'compileProcess',
+                    'evaluateTiExpression'
                 ],
                 CellService: [
                     'writeDataframeAsync',
@@ -153,7 +174,7 @@ describe('100% TM1py Parity Function Existence', () => {
             const totalFunctions = Object.values(implementedFunctions)
                 .reduce((total, funcs) => total + funcs.length, 0);
 
-            expect(totalFunctions).toBe(25); // 16 + 5 + 3 + 1
+            expect(totalFunctions).toBe(31); // 16 + 11 + 3 + 1
             
             console.log('🎉 100% TM1py Parity Achieved!');
             console.log(`✅ ${implementedFunctions.ElementService.length} ElementService functions`);

package/src/tests/applicationService.issue38.test.ts

@@ -0,0 +1,293 @@
+/**
+ * ApplicationService Tests — Issue #38 new methods
+ */
+
+import { ApplicationService } from '../services/ApplicationService';
+import { RestService } from '../services/RestService';
+import { TM1RestException } from '../exceptions/TM1Exception';
+import { FolderApplication, CubeApplication, ApplicationTypes } from '../objects/Application';
+
+const createMockResponse = (data: any, status: number = 200) => ({
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+    headers: {},
+    config: {} as any
+});
+
+describe('ApplicationService — Issue #38 new methods', () => {
+    let applicationService: ApplicationService;
+    let mockRestService: jest.Mocked<RestService>;
+
+    beforeEach(() => {
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn(),
+            config: {} as any,
+            rest: {} as any,
+            buildBaseUrl: jest.fn(),
+            extractErrorMessage: jest.fn()
+        } as any;
+
+        applicationService = new ApplicationService(mockRestService);
+    });
+
+    // ===== discover =====
+
+    describe('discover', () => {
+        test('should return public items at root when includePrivate=false', async () => {
+            mockRestService.get.mockImplementation(async (url: string) => {
+                if (url.includes('Contents') && !url.includes('PrivateContents')) {
+                    return createMockResponse({
+                        value: [
+                            { '@odata.type': '#ibm.tm1.api.v1.CubeApplication', Name: 'SalesCube' },
+                            { '@odata.type': '#ibm.tm1.api.v1.FolderApplication', Name: 'Reports' }
+                        ]
+                    });
+                }
+                return createMockResponse({ value: [] });
+            });
+
+            const results = await applicationService.discover('', false, false);
+
+            expect(results.length).toBeGreaterThanOrEqual(2);
+            const names = results.map(r => r.name);
+            expect(names).toContain('SalesCube');
+            expect(names).toContain('Reports');
+            // All should be public
+            results.forEach(r => expect(r.is_private).toBe(false));
+        });
+
+        test('should include private items when includePrivate=true', async () => {
+            mockRestService.get.mockImplementation(async (url: string) => {
+                if (url.includes('PrivateContents')) {
+                    return createMockResponse({
+                        value: [
+                            { '@odata.type': '#ibm.tm1.api.v1.CubeApplication', Name: 'PrivateReport' }
+                        ]
+                    });
+                }
+                return createMockResponse({
+                    value: [
+                        { '@odata.type': '#ibm.tm1.api.v1.CubeApplication', Name: 'PublicCube' }
+                    ]
+                });
+            });
+
+            const results = await applicationService.discover('', true, false);
+
+            const privateItems = results.filter(r => r.is_private);
+            const publicItems = results.filter(r => !r.is_private);
+            expect(privateItems.length).toBeGreaterThanOrEqual(1);
+            expect(publicItems.length).toBeGreaterThanOrEqual(1);
+            const privateNames = privateItems.map(r => r.name);
+            expect(privateNames).toContain('PrivateReport');
+        });
+
+        test('should find private items inside public folders with includePrivate', async () => {
+            mockRestService.get.mockImplementation(async (url: string) => {
+                // Public root contents: one public folder
+                if (url === "/Contents('Applications')/Contents") {
+                    return createMockResponse({
+                        value: [
+                            { '@odata.type': '#ibm.tm1.api.v1.CubeApplication', Name: 'PublicCube' }
+                        ]
+                    });
+                }
+                // Private root contents: uses public path + PrivateContents leaf
+                if (url === "/Contents('Applications')/PrivateContents") {
+                    return createMockResponse({
+                        value: [
+                            { '@odata.type': '#ibm.tm1.api.v1.CubeApplication', Name: 'PrivateInPublicRoot' }
+                        ]
+                    });
+                }
+                return createMockResponse({ value: [] });
+            });
+
+            const results = await applicationService.discover('', true, false);
+
+            const names = results.map(r => r.name);
+            expect(names).toContain('PublicCube');
+            expect(names).toContain('PrivateInPublicRoot');
+            const privateItem = results.find(r => r.name === 'PrivateInPublicRoot');
+            expect(privateItem?.is_private).toBe(true);
+        });
+
+        test('should recurse into folders when recursive=true', async () => {
+            // TM1 returns @odata.type like '#ibm.tm1.api.v1.FolderApplication'.
+            // _extractTypeFromOdata strips 'Application' suffix → 'Folder', which triggers recursion.
+            mockRestService.get.mockImplementation(async (url: string) => {
+                if (url.includes('PrivateContents')) {
+                    return createMockResponse({ value: [] });
+                }
+                // Root Contents call
+                if (url.match(/Contents\('Applications'\)\/Contents$/)) {
+                    return createMockResponse({
+                        value: [
+                            { '@odata.type': '#ibm.tm1.api.v1.FolderApplication', Name: 'Reports' }
+                        ]
+                    });
+                }
+                // Sub-folder Contents call
+                if (url.includes("Contents('Reports')/Contents")) {
+                    return createMockResponse({
+                        value: [
+                            { '@odata.type': '#ibm.tm1.api.v1.CubeApplication', Name: 'SalesReport' }
+                        ]
+                    });
+                }
+                return createMockResponse({ value: [] });
+            });
+
+            const results = await applicationService.discover('', false, true);
+
+            const names = results.map(r => r.name);
+            expect(names).toContain('Reports');
+            expect(names).toContain('SalesReport');
+        });
+
+        test('should use PrivateContents for nested paths in private context', async () => {
+            mockRestService.get.mockImplementation(async (url: string) => {
+                // Root private contents returns a folder
+                if (url === "/Contents('Applications')/PrivateContents") {
+                    return createMockResponse({
+                        value: [
+                            { '@odata.type': '#ibm.tm1.api.v1.FolderApplication', Name: 'PrivateFolder' }
+                        ]
+                    });
+                }
+                // Nested private folder contents — must use PrivateContents, not Contents
+                if (url.includes("PrivateContents('PrivateFolder')/PrivateContents")) {
+                    return createMockResponse({
+                        value: [
+                            { '@odata.type': '#ibm.tm1.api.v1.CubeApplication', Name: 'DeepCube' }
+                        ]
+                    });
+                }
+                // If the code incorrectly uses Contents for nested private paths, this will 404
+                if (url.includes("Contents('PrivateFolder')/Contents")) {
+                    throw new TM1RestException('Not found', 404, { status: 404 });
+                }
+                return createMockResponse({ value: [] });
+            });
+
+            const results = await applicationService.discover('', true, true);
+
+            const names = results.map(r => r.name);
+            expect(names).toContain('PrivateFolder');
+            expect(names).toContain('DeepCube');
+        });
+
+        test('should return empty array on 404', async () => {
+            mockRestService.get.mockRejectedValue(
+                new TM1RestException('Not found', 404, { status: 404 })
+            );
+
+            const results = await applicationService.discover('NonExistentPath', false, false);
+
+            expect(results).toEqual([]);
+        });
+
+        test('should include type in result items', async () => {
+            mockRestService.get.mockImplementation(async (url: string) => {
+                if (url.includes('PrivateContents')) {
+                    return createMockResponse({ value: [] });
+                }
+                return createMockResponse({
+                    value: [
+                        { '@odata.type': '#ibm.tm1.api.v1.CubeApplication', Name: 'MyCube' }
+                    ]
+                });
+            });
+
+            const results = await applicationService.discover('', false, false);
+
+            const cubeItem = results.find(r => r.name === 'MyCube');
+            expect(cubeItem).toBeDefined();
+            expect(cubeItem?.type).toBe('Cube');
+        });
+    });
+
+    // ===== getNames with private path resolution (_resolvePath) =====
+
+    describe('getNames — private path', () => {
+        test('should use PrivateContents leaf collection even when parent path is public', async () => {
+            const calledUrls: string[] = [];
+            mockRestService.get.mockImplementation(async (url: string) => {
+                calledUrls.push(url);
+                if (url.includes('?$top=0')) {
+                    // Public path probe succeeds — folder is public
+                    return createMockResponse({});
+                }
+                if (url.includes('/PrivateContents')) {
+                    return createMockResponse({
+                        value: [{ Name: 'PrivateApp' }]
+                    });
+                }
+                return createMockResponse({
+                    value: [{ Name: 'PublicApp' }]
+                });
+            });
+
+            const names = await applicationService.getNames('MyFolder', true);
+
+            expect(names).toContain('PrivateApp');
+            // The final data-fetch URL must use PrivateContents for the leaf
+            const dataUrl = calledUrls.find(u => !u.includes('$top=0') && u.includes('PrivateContents'));
+            expect(dataUrl).toBeDefined();
+        });
+    });
+
+    // ===== exists with private path =====
+
+    describe('exists — private path', () => {
+        test('should use _resolvePath for private paths', async () => {
+            // Simulate all-public probe succeeds
+            mockRestService.get.mockImplementation(async (url: string) => {
+                if (url.includes('?$top=0')) {
+                    return createMockResponse({});
+                }
+                // exists check — return 200
+                return createMockResponse({ Name: 'MyCubeApp' });
+            });
+
+            const result = await applicationService.exists(
+                'MyFolder',
+                ApplicationTypes.CUBE,
+                'MyCubeApp',
+                true
+            );
+
+            expect(typeof result).toBe('boolean');
+        });
+
+        test('should return false when private path resolution fails with not-found', async () => {
+            mockRestService.get.mockRejectedValue(
+                new TM1RestException('Not found', 404, { status: 404 })
+            );
+
+            const result = await applicationService.exists(
+                'NonExistent',
+                ApplicationTypes.CUBE,
+                'SomeCube',
+                true
+            );
+
+            expect(result).toBe(false);
+        });
+
+        test('should rethrow server errors from private exists', async () => {
+            mockRestService.get.mockRejectedValue(
+                new TM1RestException('Internal server error', 500, { status: 500 })
+            );
+
+            await expect(
+                applicationService.exists('SomePath', ApplicationTypes.CUBE, 'SomeCube', true)
+            ).rejects.toThrow('Internal server error');
+        });
+    });
+});