tm1npm 1.6.0 → 2.1.0

package/src/tests/tm1Service.test.ts

@@ -6,6 +6,7 @@
 
 import { TM1Service } from '../services/TM1Service';
 import { RestService, RestServiceConfig } from '../services/RestService';
+import { User, UserType } from '../objects/User';
 
 // Mock all service dependencies
 jest.mock('../services/RestService');
@@ -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: TM1Service;
@@ -61,6 +75,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,
         } as any;
 
         // Mock RestService constructor
@@ -83,6 +99,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', () => {
@@ -145,16 +162,18 @@ 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('test-user', ['ADMIN'], 'Test User', undefined, UserType.Admin, true);
             const mockSecurityService = {
-                getCurrentUser: jest.fn().mockResolvedValue({ name: 'test-user' })
+                getCurrentUser: jest.fn().mockResolvedValue(expectedUser)
             };
             (tm1Service.security as any) = mockSecurityService;
 
             const result = await tm1Service.whoami();
-            
-            expect(result).toBe('test-user');
+
+            expect(result).toBeInstanceOf(User);
+            expect(result.name).toBe('test-user');
+            expect(result).toBe(expectedUser);
             expect(mockSecurityService.getCurrentUser).toHaveBeenCalledTimes(1);
         });
 
@@ -175,10 +194,11 @@ describe('TM1Service', () => {
 
         test('should re-authenticate successfully', async () => {
             await tm1Service.reAuthenticate();
-            
+
             expect(mockRestService.disconnect).toHaveBeenCalledTimes(1);
             expect(mockRestService.connect).toHaveBeenCalledTimes(1);
         });
+
     });
 
     describe('Metadata and Version', () => {
@@ -191,13 +211,13 @@ describe('TM1Service', () => {
             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 () => {
@@ -209,7 +229,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');
         });
@@ -358,4 +378,68 @@ describe('TM1Service', () => {
             expect(monitoring1).toBe(monitoring2);
         });
     });
+
+    describe('Lazy Services (Issue #82)', () => {
+        const lazyServiceNames: Array<keyof TM1Service> = [
+            '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);
+        });
+    });
 });

package/src/tests/user.issue61.test.ts

@@ -0,0 +1,206 @@
+import { User, UserType } from '../objects/User';
+import { CaseAndSpaceInsensitiveSet } from '../utils/Utils';
+
+describe('UserType — string enum (issue #61)', () => {
+    test('should produce correct string names from toString()', () => {
+        expect(UserType.User.toString()).toBe('User');
+        expect(UserType.SecurityAdmin.toString()).toBe('SecurityAdmin');
+        expect(UserType.DataAdmin.toString()).toBe('DataAdmin');
+        expect(UserType.Admin.toString()).toBe('Admin');
+        expect(UserType.OperationsAdmin.toString()).toBe('OperationsAdmin');
+    });
+
+    test('should serialize Type field as string name in body', () => {
+        const user = new User('Alice', [], undefined, undefined, UserType.Admin);
+        const body = JSON.parse(user.body);
+        expect(body.Type).toBe('Admin');
+    });
+
+    test('should serialize User type as "User" string in body', () => {
+        const user = new User('Alice', []);
+        const body = JSON.parse(user.body);
+        expect(body.Type).toBe('User');
+    });
+
+    test('should parse string value in userType setter', () => {
+        const user = new User('Alice', []);
+        user.userType = 'Admin';
+        expect(user.userType).toBe(UserType.Admin);
+    });
+
+    test('should parse case-insensitive string in userType setter', () => {
+        const user = new User('Alice', []);
+        user.userType = 'admin';
+        expect(user.userType).toBe(UserType.Admin);
+    });
+
+    test('should throw on invalid userType string', () => {
+        const user = new User('Alice', []);
+        expect(() => { user.userType = 'InvalidType'; }).toThrow();
+    });
+});
+
+describe('User — group auto-detection (issue #61)', () => {
+    test('should detect Admin type from groups', () => {
+        const user = new User('Alice', ['Admin']);
+        expect(user.userType).toBe(UserType.Admin);
+    });
+
+    test('should detect SecurityAdmin type from groups', () => {
+        const user = new User('Alice', ['SecurityAdmin']);
+        expect(user.userType).toBe(UserType.SecurityAdmin);
+    });
+
+    test('should detect DataAdmin type from groups', () => {
+        const user = new User('Alice', ['DataAdmin']);
+        expect(user.userType).toBe(UserType.DataAdmin);
+    });
+
+    test('should detect OperationsAdmin type from groups', () => {
+        const user = new User('Alice', ['OperationsAdmin']);
+        expect(user.userType).toBe(UserType.OperationsAdmin);
+    });
+
+    test('should default to User type when no special groups present', () => {
+        const user = new User('Alice', ['Everyone', 'SomeTeam']);
+        expect(user.userType).toBe(UserType.User);
+    });
+
+    test('should add correct string group when userType set to Admin', () => {
+        const user = new User('Alice', []);
+        user.userType = UserType.Admin;
+        expect(user.groups).toContain('Admin');
+    });
+
+    test('should not add a group when userType set to User', () => {
+        const user = new User('Alice', []);
+        user.userType = UserType.User;
+        expect(user.groups).toHaveLength(0);
+    });
+});
+
+describe('User — isXxxAdmin getters (issue #61)', () => {
+    test('should return true for isAdmin when Admin group present', () => {
+        const user = new User('Alice', ['Admin']);
+        expect(user.isAdmin).toBe(true);
+    });
+
+    test('should return false for isAdmin when Admin group absent', () => {
+        const user = new User('Alice', ['Everyone']);
+        expect(user.isAdmin).toBe(false);
+    });
+
+    test('should return true for isDataAdmin when Admin group present', () => {
+        const user = new User('Alice', ['Admin']);
+        expect(user.isDataAdmin).toBe(true);
+    });
+
+    test('should return true for isDataAdmin when DataAdmin group present', () => {
+        const user = new User('Alice', ['DataAdmin']);
+        expect(user.isDataAdmin).toBe(true);
+    });
+
+    test('should return true for isSecurityAdmin when SecurityAdmin group present', () => {
+        const user = new User('Alice', ['SecurityAdmin']);
+        expect(user.isSecurityAdmin).toBe(true);
+    });
+
+    test('should return true for isOpsAdmin when OperationsAdmin group present', () => {
+        const user = new User('Alice', ['OperationsAdmin']);
+        expect(user.isOpsAdmin).toBe(true);
+    });
+});
+
+describe('User.fromDict — Type field parsing (issue #61)', () => {
+    test('should parse Type string field from API response dict', () => {
+        const dict = {
+            Name: 'Alice',
+            FriendlyName: 'Alice',
+            Groups: [{ Name: 'Admin' }],
+            Type: 'Admin',
+            Enabled: true,
+        };
+        const user = User.fromDict(dict);
+        expect(user.userType).toBe(UserType.Admin);
+    });
+
+    test('should parse SecurityAdmin Type field from API response dict', () => {
+        const dict = {
+            Name: 'Bob',
+            FriendlyName: 'Bob',
+            Groups: [{ Name: 'SecurityAdmin' }],
+            Type: 'SecurityAdmin',
+            Enabled: true,
+        };
+        const user = User.fromDict(dict);
+        expect(user.userType).toBe(UserType.SecurityAdmin);
+    });
+});
+
+describe('CaseAndSpaceInsensitiveSet — casing preservation (issue #61)', () => {
+    test('should preserve original casing of first insertion', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('Admin');
+        set.add('ADMIN');
+        set.add('admin');
+        expect(set.size).toBe(1);
+        expect(Array.from(set)).toEqual(['Admin']);
+    });
+
+    test('should find by any casing variant', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('HelloWorld');
+        expect(set.has('helloworld')).toBe(true);
+        expect(set.has('HELLOWORLD')).toBe(true);
+        expect(set.has('Hello World')).toBe(true);
+        expect(set.has('hello world')).toBe(true);
+    });
+
+    test('should return first-inserted casing during iteration', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('MyGroup');
+        set.add('mygroup');
+        set.add('MYGROUP');
+        expect(Array.from(set)).toEqual(['MyGroup']);
+    });
+
+    test('should delete by any casing variant', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('Admin');
+        expect(set.delete('ADMIN')).toBe(true);
+        expect(set.size).toBe(0);
+        expect(set.has('Admin')).toBe(false);
+    });
+
+    test('should return false when deleting non-existent entry', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        expect(set.delete('NonExistent')).toBe(false);
+    });
+
+    test('should maintain correct size after operations', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('A');
+        set.add('B');
+        set.add('a'); // duplicate — ignored
+        expect(set.size).toBe(2);
+        set.delete('A');
+        expect(set.size).toBe(1);
+    });
+
+    test('should clear all entries', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('A');
+        set.add('B');
+        set.clear();
+        expect(set.size).toBe(0);
+        expect(set.has('A')).toBe(false);
+    });
+
+    test('should handle values with spaces', () => {
+        const set = new CaseAndSpaceInsensitiveSet();
+        set.add('Data Admin');
+        expect(set.has('dataadmin')).toBe(true);
+        expect(set.has('DataAdmin')).toBe(true);
+        expect(Array.from(set)).toEqual(['Data Admin']);
+    });
+});

package/src/utils/Utils.ts

@@ -65,20 +65,42 @@ export class CaseAndSpaceInsensitiveMap<T> extends Map<string, T> {
 }
 
 export class CaseAndSpaceInsensitiveSet extends Set<string> {
-    private normalizeValue(value: string): string {
-        return value.toLowerCase().replace(/\s+/g, '');
+    private _normalizedMap: Map<string, string>;
+
+    constructor(values?: Iterable<string>) {
+        super();
+        this._normalizedMap = new Map<string, string>();
+        if (values) {
+            for (const v of values) {
+                this.add(v);
+            }
+        }
     }
 
     add(value: string): this {
-        return super.add(this.normalizeValue(value));
+        const key = lowerAndDropSpaces(value);
+        if (!this._normalizedMap.has(key)) {
+            this._normalizedMap.set(key, value);
+            super.add(value);
+        }
+        return this;
     }
 
     has(value: string): boolean {
-        return super.has(this.normalizeValue(value));
+        return this._normalizedMap.has(lowerAndDropSpaces(value));
     }
 
     delete(value: string): boolean {
-        return super.delete(this.normalizeValue(value));
+        const key = lowerAndDropSpaces(value);
+        const original = this._normalizedMap.get(key);
+        if (original === undefined) return false;
+        this._normalizedMap.delete(key);
+        return super.delete(original);
+    }
+
+    clear(): void {
+        this._normalizedMap.clear();
+        super.clear();
     }
 }
 
@@ -98,6 +120,15 @@ export function escapeODataValue(str: string): string {
     return str.replace(/'/g, "''");
 }
 
+export function buildUrlFriendlyObjectName(objectName: string): string {
+    return objectName
+        .replace(/'/g, "''")
+        .replace(/%/g, "%25")
+        .replace(/#/g, "%23")
+        .replace(/\?/g, "%3F")
+        .replace(/&/g, "%26");
+}
+
 export function formatUrl(template: string, ...args: string[]): string {
     let url = template;
     for (const arg of args) {
@@ -336,8 +367,29 @@ export function verifyVersion(actualVersion: string, requiredVersion: string): b
     return true; // Equal versions
 }
 
-export function readObjectNameFromUrl(url: string): string {
-    // Extract object name from URL like "/Dimensions('DimName')" -> "DimName"
+// Overloads preserve the narrow `string` return for the existing no-pattern form
+// (published npm API — widening to `string | null` would break downstream consumers).
+export function readObjectNameFromUrl(url: string): string;
+export function readObjectNameFromUrl(url: string, pattern: string | RegExp): string | null;
+export function readObjectNameFromUrl(url: string, pattern?: string | RegExp): string | null {
+    // tm1py parity: when `pattern` is provided, behave like
+    // `re.match(pattern, url)` + `unquote(match.group(1))` — anchored at start,
+    // URL-decodes the first capture group, returns null on no match.
+    if (pattern !== undefined) {
+        const re = typeof pattern === 'string'
+            ? new RegExp(pattern.startsWith('^') ? pattern : '^' + pattern)
+            : pattern;
+        const m = url.match(re);
+        if (!m || m[1] === undefined) return null;
+        try {
+            return decodeURIComponent(m[1]);
+        } catch {
+            // tm1py parity: urllib.parse.unquote is permissive on malformed %XX
+            // (returns the original string). decodeURIComponent throws — fall back.
+            return m[1];
+        }
+    }
+    // Backward-compat: extract first ('name') segment, return '' on no match
     const match = url.match(/\('([^']+)'\)/);
     return match ? match[1] : '';
 }
@@ -395,6 +447,7 @@ export const Utils = {
     CaseAndSpaceInsensitiveSet,
     caseAndSpaceInsensitiveEquals,
     lowerAndDropSpaces,
+    buildUrlFriendlyObjectName,
     formatUrl,
     extractCellsetCells,
     buildMdxFromAxes,