tm1npm 1.5.3 → 2.0.0

package/lib/tests/subsetService.issue38.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SubsetService Tests — Issue #38 new methods
+ */
+export {};
+//# sourceMappingURL=subsetService.issue38.test.d.ts.map

package/lib/tests/subsetService.issue38.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subsetService.issue38.test.d.ts","sourceRoot":"","sources":["../../src/tests/subsetService.issue38.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/lib/tests/subsetService.issue38.test.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * SubsetService Tests — Issue #38 new methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SubsetService_1 = require("../services/SubsetService");
+const Subset_1 = require("../objects/Subset");
+const Element_1 = require("../objects/Element");
+const createMockResponse = (data, status = 200) => ({
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+    headers: {},
+    config: {}
+});
+describe('SubsetService — Issue #38 new methods', () => {
+    let subsetService;
+    let mockRestService;
+    beforeEach(() => {
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn(),
+            config: {},
+            rest: {},
+            buildBaseUrl: jest.fn(),
+            extractErrorMessage: jest.fn()
+        };
+        subsetService = new SubsetService_1.SubsetService(mockRestService);
+    });
+    // ===== updateStaticElements =====
+    describe('updateStaticElements', () => {
+        test('should PUT to Elements/$ref with correct @odata.id body', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+            await subsetService.updateStaticElements('MySubset', 'TestDimension', 'TestHierarchy', false, ['ElemA', 'ElemB']);
+            expect(mockRestService.put).toHaveBeenCalledTimes(1);
+            const [url, body] = mockRestService.put.mock.calls[0];
+            expect(url).toContain("Dimensions('TestDimension')/Hierarchies('TestHierarchy')");
+            expect(url).toContain("Subsets('MySubset')/Elements/$ref");
+            const parsed = JSON.parse(body);
+            expect(Array.isArray(parsed.value)).toBe(true);
+            expect(parsed.value).toHaveLength(2);
+            expect(parsed.value[0]['@odata.id']).toContain("Elements('ElemA')");
+            expect(parsed.value[1]['@odata.id']).toContain("Elements('ElemB')");
+        });
+        test('should accept a Subset object and use its elements', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+            const subset = new Subset_1.Subset('MySubset', 'TestDimension', 'TestHierarchy', undefined, undefined, ['X', 'Y', 'Z']);
+            await subsetService.updateStaticElements(subset);
+            expect(mockRestService.put).toHaveBeenCalledTimes(1);
+            const [, body] = mockRestService.put.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed.value).toHaveLength(3);
+            expect(parsed.value[0]['@odata.id']).toContain("Elements('X')");
+            expect(parsed.value[2]['@odata.id']).toContain("Elements('Z')");
+        });
+        test('should accept a Subset object with overriding elements array', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+            const subset = new Subset_1.Subset('MySubset', 'TestDimension', 'TestHierarchy', undefined, undefined, ['X', 'Y']);
+            // Override elements explicitly
+            await subsetService.updateStaticElements(subset, undefined, undefined, false, ['Override1']);
+            const [, body] = mockRestService.put.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed.value).toHaveLength(1);
+            expect(parsed.value[0]['@odata.id']).toContain("Elements('Override1')");
+        });
+        test('should accept Element objects (not just strings)', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+            const elem1 = new Element_1.Element('Alpha', Element_1.ElementType.NUMERIC);
+            const elem2 = new Element_1.Element('Beta', Element_1.ElementType.NUMERIC);
+            await subsetService.updateStaticElements('MySubset', 'TestDimension', 'TestHierarchy', false, [elem1, elem2]);
+            const [, body] = mockRestService.put.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed.value[0]['@odata.id']).toContain("Elements('Alpha')");
+            expect(parsed.value[1]['@odata.id']).toContain("Elements('Beta')");
+        });
+        test('should use PrivateSubsets collection when isPrivate=true', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+            await subsetService.updateStaticElements('PrivateSubset', 'TestDimension', 'TestHierarchy', true, ['E1']);
+            const [url] = mockRestService.put.mock.calls[0];
+            expect(url).toContain('PrivateSubsets');
+            // PrivateSubsets is the only subsets segment — there must be no plain '/Subsets(' prefix
+            expect(url).not.toMatch(/\/Subsets\(/);
+        });
+        test('should use public Subsets collection when isPrivate=false', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+            await subsetService.updateStaticElements('PublicSubset', 'TestDimension', 'TestHierarchy', false, ['E1']);
+            const [url] = mockRestService.put.mock.calls[0];
+            expect(url).toContain("Subsets('PublicSubset')");
+            expect(url).not.toContain('PrivateSubsets');
+        });
+        test('should throw when dimensionName is missing for string argument', async () => {
+            await expect(subsetService.updateStaticElements('MySubset', undefined, 'TestHierarchy', false, ['E1'])).rejects.toThrow('dimensionName is required when passing subset name as string');
+        });
+        test('should default hierarchyName to dimensionName for string argument', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+            await subsetService.updateStaticElements('MySubset', 'TestDimension', undefined, // no hierarchyName — should default to dimensionName
+            false, ['E1']);
+            const [url] = mockRestService.put.mock.calls[0];
+            expect(url).toContain("Hierarchies('TestDimension')");
+        });
+        test('should send empty value array when no elements provided', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+            await subsetService.updateStaticElements('EmptySubset', 'TestDimension', 'TestHierarchy', false, []);
+            const [, body] = mockRestService.put.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed.value).toEqual([]);
+        });
+    });
+});
+//# sourceMappingURL=subsetService.issue38.test.js.map

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.5.3",
+  "version": "2.0.0",
   "description": "A Node.js module for TM1",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/index.ts

@@ -11,7 +11,7 @@ export {
     CubeService,
     ElementService,
     CellService,
-    ProcessService,
+    ProcessService, CompileSyntaxError,
     ViewService,
     SecurityService,
     FileService,

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';
@@ -17,12 +17,19 @@ import {
     getApplicationMetadata
 } from '../objects/Application';
 import { formatUrl, verifyVersion } from '../utils/Utils';
+import { TM1RestException } from '../exceptions/TM1Exception';
 
 export class ApplicationService extends ObjectService {
+    private pathCache: Map<string, number> = new Map();
+
     constructor(rest: RestService) {
         super(rest);
     }
 
+    public clearPathCache(): void {
+        this.pathCache.clear();
+    }
+
     public async getAllPublicRootNames(): Promise<string[]> {
         const url = "/Contents('Applications')/Contents";
         const response = await this.rest.get(url);
@@ -35,7 +42,14 @@ export class ApplicationService extends ObjectService {
         return response.data.value.map((application: any) => application.Name);
     }
 
-    public async getNames(path: string, isPrivate: boolean = false): Promise<string[]> {
+    public async getNames(path: string, isPrivate: boolean = false, useCache: boolean = false): Promise<string[]> {
+        if (isPrivate) {
+            const resolved = await this._resolvePath(path, true, useCache);
+            // Leaf collection is always PrivateContents when isPrivate — even if parent path is public
+            const url = resolved.baseUrl + '/PrivateContents';
+            const response = await this.rest.get(url);
+            return response.data.value.map((application: any) => application.Name);
+        }
         const contents = this.getContentsCollection(isPrivate);
         const mid = this.buildPathSegments(path);
         const baseUrl = "/Contents('Applications')" + mid + "/" + contents;
@@ -47,7 +61,8 @@ export class ApplicationService extends ObjectService {
         path: string,
         applicationType: string | ApplicationTypes,
         name: string,
-        isPrivate: boolean = false
+        isPrivate: boolean = false,
+        useCache: boolean = false
     ): Promise<Application> {
         const appType = this.parseApplicationType(applicationType);
 
@@ -56,7 +71,13 @@ export class ApplicationService extends ObjectService {
         }
 
         const requestName = this.withLegacySuffix(name, appType);
-        const baseUrl = this.buildApplicationUrl(path, isPrivate, requestName);
+        let baseUrl: string;
+        if (isPrivate) {
+            const resolved = await this._resolvePath(path, true, useCache);
+            baseUrl = formatUrl(resolved.baseUrl + "/PrivateContents('{}')", requestName);
+        } else {
+            baseUrl = this.buildApplicationUrl(path, isPrivate, requestName);
+        }
 
         switch (appType) {
             case ApplicationTypes.CUBE: {
@@ -79,7 +100,6 @@ export class ApplicationService extends ObjectService {
                 return new FolderApplication(path, name);
             }
             case ApplicationTypes.LINK: {
-                await this.rest.get(baseUrl);
                 const response = await this.rest.get(baseUrl + "?$expand=*");
                 return new LinkApplication(path, response.data?.Name || name, response.data?.URL || '');
             }
@@ -132,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);
@@ -163,7 +183,7 @@ export class ApplicationService extends ObjectService {
             );
             await this.rest.put(contentUrl, application.content, {
                 headers: this.binaryHttpHeader
-            } as AxiosRequestConfig);
+            });
         }
 
         return response;
@@ -184,7 +204,7 @@ export class ApplicationService extends ObjectService {
             );
             return await this.rest.post(url, application.content, {
                 headers: this.binaryHttpHeader
-            } as AxiosRequestConfig);
+            });
         }
 
         const url = formatUrl(
@@ -232,11 +252,28 @@ export class ApplicationService extends ObjectService {
         path: string,
         applicationType: ApplicationTypes,
         name: string,
-        isPrivate: boolean = false
+        isPrivate: boolean = false,
+        useCache: boolean = false
     ): Promise<boolean> {
+        const requestName = this.withLegacySuffix(name, applicationType);
+        if (isPrivate) {
+            try {
+                const resolved = await this._resolvePath(path, true, useCache);
+                const url = formatUrl(resolved.baseUrl + "/PrivateContents('{}')", requestName);
+                return await this._exists(url);
+            } catch (error: any) {
+                // Path-not-found from _resolvePath means item doesn't exist
+                if (error instanceof Error && error.message.includes('not found')) {
+                    return false;
+                }
+                if (error instanceof TM1RestException && error.statusCode === 404) {
+                    return false;
+                }
+                throw error;
+            }
+        }
         const contents = this.getContentsCollection(isPrivate);
         const mid = this.buildPathSegments(path);
-        const requestName = this.withLegacySuffix(name, applicationType);
         const url = formatUrl(
             "/Contents('Applications')" + mid + "/" + contents + "('{}')",
             requestName
@@ -287,6 +324,230 @@ export class ApplicationService extends ObjectService {
         return await this.update(document, isPrivate);
     }
 
+    // NOTE: `flat` parameter is accepted for tm1py signature parity but output is always flat.
+    // Nested (tree) mode is not yet implemented.
+    public async discover(
+        path: string = '',
+        includePrivate: boolean = false,
+        recursive: boolean = false,
+        _flat: boolean = false
+    ): Promise<Array<{ type: string; name: string; path: string; is_private: boolean }>> {
+        return this._discoverAtPath(path, includePrivate, recursive, false);
+    }
+
+    private async _discoverAtPath(
+        path: string,
+        includePrivate: boolean,
+        recursive: boolean,
+        inPrivateContext: boolean
+    ): Promise<Array<{ type: string; name: string; path: string; is_private: boolean }>> {
+        const results: Array<{ type: string; name: string; path: string; is_private: boolean }> = [];
+
+        if (!inPrivateContext) {
+            const publicItems = await this._getContentsRaw(path, false, false);
+            const processed = await this._processItems(
+                publicItems, path, false, includePrivate, recursive, false
+            );
+            results.push(...processed);
+        }
+
+        if (includePrivate || inPrivateContext) {
+            const privateItems = await this._getContentsRaw(path, true, inPrivateContext);
+            const processed = await this._processItems(
+                privateItems, path, true, includePrivate, recursive, true
+            );
+            results.push(...processed);
+        }
+
+        return results;
+    }
+
+    private async _getContentsRaw(path: string, isPrivate: boolean, inPrivateContext: boolean): Promise<any[]> {
+        try {
+            // Path segments: use PrivateContents only if we're already inside a private folder tree.
+            // Leaf collection: PrivateContents if isPrivate or inPrivateContext, else Contents.
+            const mid = inPrivateContext
+                ? this.buildPrivatePathSegments(path)
+                : this.buildPathSegments(path);
+            const collection = (inPrivateContext || isPrivate) ? 'PrivateContents' : 'Contents';
+            const url = "/Contents('Applications')" + mid + "/" + collection;
+            const response = await this.rest.get(url);
+            return response.data?.value || [];
+        } catch (error: any) {
+            if (error instanceof TM1RestException && error.statusCode === 404) {
+                return [];
+            }
+            throw error;
+        }
+    }
+
+    private async _processItems(
+        items: any[],
+        path: string,
+        isPrivate: boolean,
+        includePrivate: boolean,
+        recursive: boolean,
+        inPrivateContext: boolean
+    ): Promise<Array<{ type: string; name: string; path: string; is_private: boolean }>> {
+        const results: Array<{ type: string; name: string; path: string; is_private: boolean }> = [];
+
+        const folderPromises: Array<Promise<Array<{ type: string; name: string; path: string; is_private: boolean }>>> = [];
+
+        for (const item of items) {
+            const odataType = item['@odata.type'] || '';
+            const typeName = this._extractTypeFromOdata(odataType);
+            const itemName = item.Name || '';
+            const itemPath = path ? `${path}/${itemName}` : itemName;
+
+            results.push({
+                type: typeName,
+                name: itemName,
+                path: itemPath,
+                is_private: isPrivate || inPrivateContext
+            });
+
+            if (recursive && typeName === 'Folder') {
+                folderPromises.push(
+                    this._discoverAtPath(
+                        itemPath, includePrivate, recursive, inPrivateContext || isPrivate
+                    )
+                );
+            }
+        }
+
+        const folderResults = await Promise.all(folderPromises);
+        for (const subItems of folderResults) {
+            results.push(...subItems);
+        }
+
+        return results;
+    }
+
+    private _extractTypeFromOdata(odataType: string): string {
+        if (!odataType) return 'Unknown';
+        const parts = odataType.split('.');
+        const raw = parts[parts.length - 1] || 'Unknown';
+        // TM1 returns types like 'FolderApplication', 'CubeApplication' — strip suffix
+        // so folder check works consistently
+        return raw.replace(/Application$/, '') || raw;
+    }
+
+    private async _findPrivateBoundary(segments: string[]): Promise<number> {
+        let publicUrl = "/Contents('Applications')";
+        for (let i = 0; i < segments.length; i++) {
+            const testUrl = publicUrl + formatUrl("/Contents('{}')", segments[i]) + "?$top=0";
+            try {
+                await this.rest.get(testUrl);
+                publicUrl += formatUrl("/Contents('{}')", segments[i]);
+            } catch (error: any) {
+                if (error instanceof TM1RestException && error.statusCode === 404) {
+                    const privateTestUrl = publicUrl + formatUrl("/PrivateContents('{}')", segments[i]) + "?$top=0";
+                    try {
+                        await this.rest.get(privateTestUrl);
+                        return i;
+                    } catch (innerError: any) {
+                        if (innerError instanceof TM1RestException && innerError.statusCode === 404) {
+                            return -1;
+                        }
+                        throw innerError;
+                    }
+                }
+                throw error;
+            }
+        }
+        return segments.length;
+    }
+
+    private _buildPathUrl(segments: string[], privateBoundary?: number): string {
+        if (!segments.length) return '';
+
+        let url = '';
+        const boundary = privateBoundary ?? segments.length;
+
+        for (let i = 0; i < segments.length; i++) {
+            if (i < boundary) {
+                url += formatUrl("/Contents('{}')", segments[i]);
+            } else {
+                url += formatUrl("/PrivateContents('{}')", segments[i]);
+            }
+        }
+        return url;
+    }
+
+    private async _resolvePath(
+        path: string,
+        isPrivate: boolean = false,
+        useCache: boolean = false
+    ): Promise<{ baseUrl: string; inPrivateContext: boolean }> {
+        if (!path || !path.trim()) {
+            return { baseUrl: "/Contents('Applications')", inPrivateContext: isPrivate };
+        }
+
+        const segments = path.split('/').filter(s => s.trim().length > 0);
+
+        if (!isPrivate) {
+            const mid = segments.map(s => formatUrl("/Contents('{}')", s)).join('');
+            return { baseUrl: "/Contents('Applications')" + mid, inPrivateContext: false };
+        }
+
+        const cacheKey = path;
+        if (useCache && this.pathCache.has(cacheKey)) {
+            const boundary = this.pathCache.get(cacheKey)!;
+            const mid = this._buildPathUrl(segments, boundary);
+            return {
+                baseUrl: "/Contents('Applications')" + mid,
+                inPrivateContext: boundary < segments.length
+            };
+        }
+
+        // Try all-public first (optimistic)
+        try {
+            const publicUrl = "/Contents('Applications')" +
+                segments.map(s => formatUrl("/Contents('{}')", s)).join('') + "?$top=0";
+            await this.rest.get(publicUrl);
+            if (useCache) this.pathCache.set(cacheKey, segments.length);
+            return {
+                baseUrl: "/Contents('Applications')" +
+                    segments.map(s => formatUrl("/Contents('{}')", s)).join(''),
+                inPrivateContext: false
+            };
+        } catch (error: any) {
+            if (!(error instanceof TM1RestException && error.statusCode === 404)) {
+                throw error;
+            }
+        }
+
+        // Try all-private
+        try {
+            const privateUrl = "/Contents('Applications')" +
+                segments.map(s => formatUrl("/PrivateContents('{}')", s)).join('') + "?$top=0";
+            await this.rest.get(privateUrl);
+            if (useCache) this.pathCache.set(cacheKey, 0);
+            return {
+                baseUrl: "/Contents('Applications')" +
+                    segments.map(s => formatUrl("/PrivateContents('{}')", s)).join(''),
+                inPrivateContext: true
+            };
+        } catch (error: any) {
+            if (!(error instanceof TM1RestException && error.statusCode === 404)) {
+                throw error;
+            }
+        }
+
+        // Iterative boundary search
+        const boundary = await this._findPrivateBoundary(segments);
+        if (boundary === -1) {
+            throw new Error(`Application path not found: ${path}`);
+        }
+
+        if (useCache) this.pathCache.set(cacheKey, boundary);
+        const mid = this._buildPathUrl(segments, boundary);
+        return {
+            baseUrl: "/Contents('Applications')" + mid,
+            inPrivateContext: boundary < segments.length
+        };
+    }
+
     private parseApplicationType(applicationType: string | ApplicationTypes): ApplicationTypes {
         if (typeof applicationType === 'string') {
             const upper = applicationType.toUpperCase();
@@ -309,6 +570,17 @@ export class ApplicationService extends ObjectService {
             .join('');
     }
 
+    private buildPrivatePathSegments(path: string): string {
+        if (!path || !path.trim()) {
+            return '';
+        }
+        return path
+            .split('/')
+            .filter(segment => segment.trim().length > 0)
+            .map(segment => formatUrl("/PrivateContents('{}')", segment))
+            .join('');
+    }
+
     private getContentsCollection(isPrivate: boolean): string {
         return isPrivate ? 'PrivateContents' : 'Contents';
     }