tm1npm 1.0.0

package/src/utils/Utils.ts

@@ -0,0 +1,395 @@
+export class CaseAndSpaceInsensitiveDict<T> extends Map<string, T> {
+    private normalizeKey(key: string): string {
+        return key.toLowerCase().replace(/\s+/g, '');
+    }
+
+    set(key: string, value: T): this {
+        return super.set(this.normalizeKey(key), value);
+    }
+
+    get(key: string): T | undefined {
+        return super.get(this.normalizeKey(key));
+    }
+
+    has(key: string): boolean {
+        return super.has(this.normalizeKey(key));
+    }
+
+    delete(key: string): boolean {
+        return super.delete(this.normalizeKey(key));
+    }
+}
+
+export class CaseAndSpaceInsensitiveTuplesDict<T> extends Map<string, T> {
+    private normalizeKey(key: string): string {
+        return key.toLowerCase().replace(/\s+/g, '');
+    }
+
+    set(key: string, value: T): this {
+        return super.set(this.normalizeKey(key), value);
+    }
+
+    get(key: string): T | undefined {
+        return super.get(this.normalizeKey(key));
+    }
+
+    has(key: string): boolean {
+        return super.has(this.normalizeKey(key));
+    }
+
+    delete(key: string): boolean {
+        return super.delete(this.normalizeKey(key));
+    }
+}
+
+export class CaseAndSpaceInsensitiveMap<T> extends Map<string, T> {
+    private normalizeKey(key: string): string {
+        return key.toLowerCase().replace(/\s+/g, '');
+    }
+
+    set(key: string, value: T): this {
+        return super.set(this.normalizeKey(key), value);
+    }
+
+    get(key: string): T | undefined {
+        return super.get(this.normalizeKey(key));
+    }
+
+    has(key: string): boolean {
+        return super.has(this.normalizeKey(key));
+    }
+
+    delete(key: string): boolean {
+        return super.delete(this.normalizeKey(key));
+    }
+}
+
+export class CaseAndSpaceInsensitiveSet extends Set<string> {
+    private normalizeValue(value: string): string {
+        return value.toLowerCase().replace(/\s+/g, '');
+    }
+
+    add(value: string): this {
+        return super.add(this.normalizeValue(value));
+    }
+
+    has(value: string): boolean {
+        return super.has(this.normalizeValue(value));
+    }
+
+    delete(value: string): boolean {
+        return super.delete(this.normalizeValue(value));
+    }
+}
+
+export function caseAndSpaceInsensitiveEquals(str1: string, str2: string): boolean {
+    if (str1 === str2) return true;
+    if (!str1 || !str2) return false;
+    
+    return str1.toLowerCase().replace(/\s+/g, '') === 
+           str2.toLowerCase().replace(/\s+/g, '');
+}
+
+export function lowerAndDropSpaces(str: string): string {
+    return str.toLowerCase().replace(/\s+/g, '');
+}
+
+export function formatUrl(template: string, ...args: string[]): string {
+    let url = template;
+    for (const arg of args) {
+        url = url.replace('{}', encodeURIComponent(arg));
+    }
+    return url;
+}
+
+export function extractCellsetCells(cellset: any): any[] {
+    if (!cellset || !cellset.Cells) {
+        return [];
+    }
+    return cellset.Cells;
+}
+
+export function buildMdxFromAxes(axes: any[]): string {
+    // Simple MDX builder - can be expanded
+    if (!axes || axes.length === 0) {
+        return '';
+    }
+    
+    let mdx = 'SELECT ';
+    
+    for (let i = 0; i < axes.length; i++) {
+        if (i > 0) mdx += ', ';
+        
+        const axis = axes[i];
+        if (axis.Tuples && axis.Tuples.length > 0) {
+            const members = axis.Tuples.map((tuple: any) => {
+                if (tuple.Members) {
+                    return tuple.Members.map((member: any) => `[${member.UniqueName}]`).join(',');
+                }
+                return '';
+            }).join(',');
+            mdx += `{${members}} ON ${i}`;
+        } else {
+            mdx += `{} ON ${i}`;
+        }
+    }
+    
+    return mdx;
+}
+
+export function buildElementsStringFromIterable(elements: Iterable<string>, separator: string = ','): string {
+    return Array.from(elements).join(separator);
+}
+
+export function dimensionHierarchyElementTupleFromUniqueName(uniqueName: string): [string, string, string] {
+    // Parse [Dimension].[Hierarchy].[Element] format
+    const matches = uniqueName.match(/\[([^\]]+)\]\.\[([^\]]+)\]\.\[([^\]]+)\]/);
+    if (matches && matches.length === 4) {
+        return [matches[1], matches[2], matches[3]];
+    }
+    
+    // Fallback: assume format is Dimension.Hierarchy.Element
+    const parts = uniqueName.split('.');
+    if (parts.length >= 3) {
+        return [parts[0], parts[1], parts[2]];
+    } else if (parts.length === 2) {
+        return [parts[0], parts[0], parts[1]]; // Default hierarchy = dimension name
+    } else {
+        return [uniqueName, uniqueName, uniqueName];
+    }
+}
+
+export function buildElementUniqueNames(elements: string[], dimensionName: string, hierarchyName?: string): string[] {
+    const hierarchy = hierarchyName || dimensionName;
+    return elements.map(element => `[${dimensionName}].[${hierarchy}].[${element}]`);
+}
+
+export function dimensionHierarchyElementTupleFromString(dimensionHierarchyElement: string): [string, string, string] {
+    // Parse [Dimension].[Hierarchy].[Element] format
+    const matches = dimensionHierarchyElement.match(/\[([^\]]+)\]\.\[([^\]]+)\]\.\[([^\]]+)\]/);
+    if (matches && matches.length === 4) {
+        return [matches[1], matches[2], matches[3]];
+    }
+    
+    // Fallback: assume format is Dimension.Hierarchy.Element
+    const parts = dimensionHierarchyElement.split('.');
+    if (parts.length >= 3) {
+        return [parts[0], parts[1], parts[2]];
+    } else if (parts.length === 2) {
+        return [parts[0], parts[0], parts[1]]; // Default hierarchy = dimension name
+    } else {
+        return [dimensionHierarchyElement, dimensionHierarchyElement, dimensionHierarchyElement];
+    }
+}
+
+export function deprecatedInVersion(version: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+        
+        descriptor.value = function (this: any, ...args: any[]) {
+            console.warn(`Method ${propertyKey} is deprecated in version ${version}`);
+            return originalMethod.apply(this, args);
+        };
+    };
+}
+
+export function requireVersion(minVersion: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+        
+        descriptor.value = function (this: any, ...args: any[]) {
+            // Version check would be implemented here
+            // For now, just call the original method
+            return originalMethod.apply(this, args);
+        };
+    };
+}
+
+export function requireAdmin(target: any, propertyKey: string, descriptor: PropertyDescriptor): void {
+    const originalMethod = descriptor.value;
+    
+    descriptor.value = function (this: any, ...args: any[]) {
+        // Admin check would be implemented here
+        // For now, just call the original method
+        return originalMethod.apply(this, args);
+    };
+}
+
+export function requireDataAdmin(target: any, propertyKey: string, descriptor: PropertyDescriptor): void {
+    const originalMethod = descriptor.value;
+    
+    descriptor.value = function (this: any, ...args: any[]) {
+        // Data admin check would be implemented here
+        // For now, just call the original method
+        return originalMethod.apply(this, args);
+    };
+}
+
+export function requireSecurityAdmin(target: any, propertyKey: string, descriptor: PropertyDescriptor): void {
+    const originalMethod = descriptor.value;
+    
+    descriptor.value = function (this: any, ...args: any[]) {
+        // Security admin check would be implemented here
+        // For now, just call the original method
+        return originalMethod.apply(this, args);
+    };
+}
+
+export function requireOpsAdmin(target: any, propertyKey: string, descriptor: PropertyDescriptor): void {
+    const originalMethod = descriptor.value;
+    
+    descriptor.value = function (this: any, ...args: any[]) {
+        // Ops admin check would be implemented here
+        // For now, just call the original method
+        return originalMethod.apply(this, args);
+    };
+}
+
+export function wrapTupleInBrackets(members: string[]): string {
+    if (members.length === 1) {
+        return `[${members[0]}]`;
+    }
+    return `(${members.map(m => `[${m}]`).join(',')})`;
+}
+
+export function abbreviateString(text: string, maxLength: number): string {
+    if (!text || text.length <= maxLength) {
+        return text || '';
+    }
+    if (maxLength <= 3) {
+        return '...';
+    }
+    return text.substring(0, maxLength - 3) + '...';
+}
+
+export function getTimeFromTimeStamp(timestamp: string): Date {
+    // Parse various timestamp formats
+    try {
+        return new Date(timestamp);
+    } catch (error) {
+        // Try parsing as ISO string or other formats
+        return new Date();
+    }
+}
+
+export function addTimeToTimeStamp(timestamp: string, hours: number): string {
+    const date = getTimeFromTimeStamp(timestamp);
+    date.setHours(date.getHours() + hours);
+    return date.toISOString();
+}
+
+export function tidy(inputString: string): string {
+    if (!inputString) return '';
+    return inputString.trim().replace(/\s+/g, ' ');
+}
+
+// MDX Utility functions
+export function getMdxElementFromAttribute(attribute: string, cube: string): string {
+    return `[${cube}].[${attribute}]`;
+}
+
+export function buildMdxTuple(members: string[]): string {
+    if (members.length === 1) {
+        return members[0];
+    }
+    return `(${members.join(',')})`;
+}
+
+// Verification utilities
+export function verifyVersion(actualVersion: string, requiredVersion: string): boolean {
+    // Handle null/undefined inputs
+    if (!actualVersion || !requiredVersion) {
+        return false;
+    }
+    
+    // Simple version comparison
+    const actual = actualVersion.split('.').map(Number);
+    const required = requiredVersion.split('.').map(Number);
+    
+    for (let i = 0; i < Math.max(actual.length, required.length); i++) {
+        const a = actual[i] || 0;
+        const r = required[i] || 0;
+        
+        if (a > r) return true;
+        if (a < r) return false;
+    }
+    
+    return true; // Equal versions
+}
+
+export function readObjectNameFromUrl(url: string): string {
+    // Extract object name from URL like "/Dimensions('DimName')" -> "DimName"
+    const match = url.match(/\('([^']+)'\)/);
+    return match ? match[1] : '';
+}
+
+export function integerizeVersion(version: string): number {
+    // Convert version string like "11.8.01300.1" to integer like 1180
+    const parts = version.split('.');
+    const major = parseInt(parts[0]) || 0;
+    const minor = parseInt(parts[1]) || 0;
+    return major * 100 + minor;
+}
+
+// Frame utilities for working with tabular data
+export function frameToSignificantValue(value: any): any {
+    if (typeof value === 'number') {
+        if (Math.abs(value) < 1e-10) {
+            return 0;
+        }
+        return Number(value.toPrecision(10));
+    }
+    return value;
+}
+
+// HTTP utilities
+export class HTTPAdapterWithSocketOptions {
+    constructor(private socketOptions: any = {}) {}
+    
+    // Implementation would depend on the HTTP client being used
+}
+
+// Additional utility functions
+export function odataTrackChangesHeader(): Record<string, string> {
+    return {
+        'Prefer': 'return=representation;odata.track-changes'
+    };
+}
+
+export function utcLocalizeTime(utcTimeStr: string): Date {
+    return new Date(utcTimeStr + 'Z');
+}
+
+export function decohints(): string {
+    return 'decohints';
+}
+
+export const Utils = {
+    CaseAndSpaceInsensitiveMap,
+    CaseAndSpaceInsensitiveSet,
+    caseAndSpaceInsensitiveEquals,
+    lowerAndDropSpaces,
+    formatUrl,
+    extractCellsetCells,
+    buildMdxFromAxes,
+    buildElementsStringFromIterable,
+    dimensionHierarchyElementTupleFromString,
+    requireVersion,
+    requireAdmin,
+    requireDataAdmin,
+    requireSecurityAdmin,
+    requireOpsAdmin,
+    wrapTupleInBrackets,
+    abbreviateString,
+    getTimeFromTimeStamp,
+    addTimeToTimeStamp,
+    tidy,
+    getMdxElementFromAttribute,
+    buildMdxTuple,
+    verifyVersion,
+    frameToSignificantValue,
+    HTTPAdapterWithSocketOptions,
+    odataTrackChangesHeader,
+    utcLocalizeTime,
+    decohints
+};

package/tests/README.md

@@ -0,0 +1,57 @@
+# TM1npm Test Scripts
+
+This directory contains organized standalone test scripts for tm1npm functionality.
+
+## Directory Structure
+
+### 🔌 Connection Tests (`connection/`)
+- `test-connection.ts` - Comprehensive TM1 connection testing
+- `simple-connection-test.ts` - Basic TM1 connectivity verification  
+- `minimal-connection-test.ts` - Minimal REST API connection test
+
+### 🔒 Security Tests (`security/`)
+- `security-test.ts` - Authentication, authorization, and vulnerability tests
+
+### ⚡ Performance Tests (`performance/`)
+- `performance-test.ts` - Response time, memory usage, and scalability tests
+
+### 🎯 Edge Cases Tests (`edge-cases/`)
+- `edge-cases-test.ts` - Boundary conditions and unusual input tests
+
+### 🔗 Integration Tests (`integration/`)
+- `working-test.ts` - Comprehensive TM1 functionality test
+
+## Environment Configuration
+
+All tests use environment variables from `.env` file:
+```
+TM1_ADDRESS=localhost
+TM1_PORT=8879
+TM1_USER=admin
+TM1_PASSWORD=your_password_here
+TM1_SSL=false
+```
+
+## Running Tests
+
+### Individual Test Categories
+```bash
+npm run test:connection    # Connection tests
+npm run test:simple        # Simple connection test
+npm run test:minimal       # Minimal connection test
+npm run test:working       # Integration test
+npm run test:security      # Security tests
+npm run test:performance   # Performance tests
+npm run test:edge-cases    # Edge cases tests
+```
+
+### All Tests
+```bash
+npm run test:all          # Run all test suites including Jest unit tests
+```
+
+## Security Notes
+
+- No hardcoded passwords - all credentials come from environment variables
+- Tests will fail gracefully if TM1_PASSWORD is not set
+- Production deployments should use secure credential management

package/tests/connection/test-connection.ts

@@ -0,0 +1,86 @@
+/**
+ * Simple connection test using axios directly
+ */
+
+import axios from 'axios';
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+async function simpleConnectionTest(): Promise<void> {
+    const address = process.env.TM1_ADDRESS || 'localhost';
+    const port = process.env.TM1_PORT || '8879';
+    const user = process.env.TM1_USER || 'admin';
+    const password = process.env.TM1_PASSWORD;
+
+    if (!password) {
+        console.log('❌ TM1_PASSWORD environment variable is required');
+        console.log('Please set TM1_PASSWORD in your .env file');
+        process.exit(1);
+    }
+
+    console.log('🔍 Simple TM1 Connection Test');
+    console.log(`Server: ${address}:${port}`);
+    console.log(`User: ${user}`);
+    console.log('=' .repeat(40));
+
+    const config = {
+        baseURL: `http://${address}:${port}/api/v1`,
+        auth: {
+            username: user,
+            password: password
+        },
+        timeout: 30000
+    };
+
+    try {
+        console.log('⏳ Testing basic server connectivity...');
+        
+        // Test basic server connection
+        const response = await axios.get('/Configuration/ProductVersion', config);
+        console.log('✅ Server responded successfully!');
+        console.log(`📈 TM1 Version: ${response.data.value}`);
+
+        // Test server name
+        const nameResponse = await axios.get('/Configuration/ServerName', config);
+        console.log(`🏷️ Server Name: ${nameResponse.data.value}`);
+
+        // Test basic endpoints
+        console.log('⏳ Testing basic endpoints...');
+        const cubesResponse = await axios.get('/Cubes?$top=1&$select=Name', config);
+        const dimsResponse = await axios.get('/Dimensions?$top=1&$select=Name', config);
+        
+        console.log(`📊 Found cubes: ${cubesResponse.data.value.length > 0 ? 'Yes' : 'None'}`);
+        console.log(`📁 Found dimensions: ${dimsResponse.data.value.length > 0 ? 'Yes' : 'None'}`);
+
+        console.log('\n🎉 Simple connection test PASSED!');
+        console.log('✅ TM1 server is accessible and responding correctly');
+
+    } catch (error: any) {
+        console.log('\n❌ Connection test FAILED!');
+        console.log(`Error: ${error.message || error}`);
+        
+        if (error.code === 'ECONNREFUSED') {
+            console.log('   Connection refused - server may not be running');
+        } else if (error.response?.status === 401) {
+            console.log('   Authentication failed - check username/password');
+        }
+        
+        console.log('\n🔧 Troubleshooting checklist:');
+        console.log('   □ TM1 server is running at localhost:8879');
+        console.log('   □ Username: admin');
+        console.log('   □ TM1 REST API is enabled');
+        console.log('   □ No firewall blocking port 8879');
+    }
+}
+
+// Run the test
+if (require.main === module) {
+    simpleConnectionTest().catch((error) => {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}
+
+export { simpleConnectionTest };