tm1npm 1.0.0

package/run-all-tests.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+
+/**
+ * Run all tm1npm tests in sequence
+ * This script executes all available test commands and provides a summary
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// ANSI color codes for better output
+const colors = {
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    reset: '\x1b[0m',
+    bold: '\x1b[1m'
+};
+
+// Test configurations
+const tests = [
+    {
+        name: 'Jest Tests',
+        command: 'npm',
+        args: ['test', '--', '--testTimeout=10000'],
+        description: 'Run all Jest unit tests',
+        timeout: 120000
+    },
+    {
+        name: 'Connection Test',
+        command: 'npm',
+        args: ['run', 'test:connection'],
+        description: 'Test TM1 connection with comprehensive checks',
+        timeout: 60000
+    },
+    {
+        name: 'Simple Connection Test',
+        command: 'npm',
+        args: ['run', 'test:simple'],
+        description: 'Basic TM1 connectivity test',
+        timeout: 30000
+    },
+    {
+        name: 'Minimal Connection Test',
+        command: 'npm',
+        args: ['run', 'test:minimal'],
+        description: 'Minimal connection verification',
+        timeout: 30000
+    },
+    {
+        name: 'Working Test',
+        command: 'npm',
+        args: ['run', 'test:working'],
+        description: 'Comprehensive TM1 functionality test',
+        timeout: 90000
+    },
+    {
+        name: 'Security Tests',
+        command: 'npm',
+        args: ['run', 'test:security'],
+        description: 'Security, authentication, and vulnerability tests',
+        timeout: 120000
+    },
+    {
+        name: 'Performance Tests',
+        command: 'npm',
+        args: ['run', 'test:performance'],
+        description: 'Response time, memory usage, and scalability tests',
+        timeout: 120000
+    },
+    {
+        name: 'Edge Cases Tests',
+        command: 'npm',
+        args: ['run', 'test:edge-cases'],
+        description: 'Boundary conditions and unusual input tests',
+        timeout: 90000
+    },
+    {
+        name: 'Test Coverage',
+        command: 'npm',
+        args: ['run', 'test:coverage', '--', '--testTimeout=10000'],
+        description: 'Run tests with coverage report',
+        timeout: 180000
+    }
+];
+
+// Results tracking
+const results = [];
+let totalTests = 0;
+let passedTests = 0;
+let failedTests = 0;
+
+function printHeader() {
+    console.log(`${colors.bold}${colors.cyan}╔══════════════════════════════════════════════════════════════════╗${colors.reset}`);
+    console.log(`${colors.bold}${colors.cyan}║                        TM1NPM Test Runner                       ║${colors.reset}`);
+    console.log(`${colors.bold}${colors.cyan}║                     Running All Test Suites                     ║${colors.reset}`);
+    console.log(`${colors.bold}${colors.cyan}╚══════════════════════════════════════════════════════════════════╝${colors.reset}`);
+    console.log('');
+}
+
+function printTestStart(testName, description) {
+    console.log(`${colors.blue}▶ ${colors.bold}${testName}${colors.reset}`);
+    console.log(`  ${colors.cyan}${description}${colors.reset}`);
+    console.log('  ' + '─'.repeat(60));
+}
+
+function printTestResult(testName, success, output, error) {
+    const status = success 
+        ? `${colors.green}✅ PASSED${colors.reset}` 
+        : `${colors.red}❌ FAILED${colors.reset}`;
+    
+    console.log(`  ${status} ${colors.bold}${testName}${colors.reset}`);
+    
+    if (success && output) {
+        // Show last few lines of successful output
+        const lines = output.split('\n').filter(line => line.trim());
+        const lastLines = lines.slice(-3).join('\n  ');
+        if (lastLines) {
+            console.log(`  ${colors.green}${lastLines}${colors.reset}`);
+        }
+    }
+    
+    if (!success && error) {
+        // Show error details
+        const errorLines = error.split('\n').slice(0, 5).join('\n  ');
+        console.log(`  ${colors.red}${errorLines}${colors.reset}`);
+    }
+    
+    console.log('');
+}
+
+function runTest(test) {
+    return new Promise((resolve) => {
+        totalTests++;
+        printTestStart(test.name, test.description);
+        
+        const child = spawn(test.command, test.args, {
+            stdio: 'pipe',
+            shell: true,
+            cwd: process.cwd()
+        });
+        
+        let output = '';
+        let error = '';
+        
+        child.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        
+        child.stderr.on('data', (data) => {
+            error += data.toString();
+        });
+        
+        // Set timeout
+        const timeout = setTimeout(() => {
+            child.kill('SIGTERM');
+            error = `Test timed out after ${test.timeout}ms`;
+        }, test.timeout);
+        
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            const success = code === 0;
+            
+            if (success) {
+                passedTests++;
+            } else {
+                failedTests++;
+            }
+            
+            results.push({
+                name: test.name,
+                success,
+                output: success ? output : null,
+                error: success ? null : (error || output),
+                code
+            });
+            
+            printTestResult(test.name, success, output, error || output);
+            resolve();
+        });
+        
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            failedTests++;
+            results.push({
+                name: test.name,
+                success: false,
+                error: err.message,
+                code: -1
+            });
+            printTestResult(test.name, false, null, err.message);
+            resolve();
+        });
+    });
+}
+
+function printSummary() {
+    console.log(`${colors.bold}${colors.cyan}╔══════════════════════════════════════════════════════════════════╗${colors.reset}`);
+    console.log(`${colors.bold}${colors.cyan}║                          Test Summary                            ║${colors.reset}`);
+    console.log(`${colors.bold}${colors.cyan}╚══════════════════════════════════════════════════════════════════╝${colors.reset}`);
+    console.log('');
+    
+    console.log(`${colors.bold}Total Tests:${colors.reset} ${totalTests}`);
+    console.log(`${colors.green}${colors.bold}Passed:${colors.reset} ${passedTests}`);
+    console.log(`${colors.red}${colors.bold}Failed:${colors.reset} ${failedTests}`);
+    console.log(`${colors.bold}Success Rate:${colors.reset} ${totalTests > 0 ? Math.round((passedTests / totalTests) * 100) : 0}%`);
+    console.log('');
+    
+    // Detailed results
+    console.log(`${colors.bold}Detailed Results:${colors.reset}`);
+    console.log('─'.repeat(70));
+    
+    results.forEach((result) => {
+        const status = result.success 
+            ? `${colors.green}✅ PASS${colors.reset}` 
+            : `${colors.red}❌ FAIL${colors.reset}`;
+        console.log(`${status} ${result.name}`);
+    });
+    
+    console.log('');
+    
+    // Failed tests details
+    const failedResults = results.filter(r => !r.success);
+    if (failedResults.length > 0) {
+        console.log(`${colors.red}${colors.bold}Failed Test Details:${colors.reset}`);
+        console.log('─'.repeat(70));
+        failedResults.forEach((result) => {
+            console.log(`${colors.red}${colors.bold}${result.name}:${colors.reset}`);
+            if (result.error) {
+                const errorPreview = result.error.split('\n').slice(0, 3).join('\n');
+                console.log(`  ${colors.red}${errorPreview}${colors.reset}`);
+            }
+            console.log('');
+        });
+    }
+    
+    // Final status
+    if (passedTests === totalTests) {
+        console.log(`${colors.green}${colors.bold}🎉 All tests passed! tm1npm is working correctly.${colors.reset}`);
+    } else {
+        console.log(`${colors.yellow}${colors.bold}⚠️ Some tests failed. Check the details above.${colors.reset}`);
+        
+        // Provide helpful tips
+        console.log('');
+        console.log(`${colors.bold}Troubleshooting Tips:${colors.reset}`);
+        console.log('• Ensure TM1 server is running at localhost:8879');
+        console.log('• Check if TM1 REST API is enabled');
+        console.log('• Make sure no firewall is blocking port 8879');
+        console.log('• Run individual tests with: npm run test:<testname>');
+    }
+}
+
+async function runAllTests() {
+    printHeader();
+    
+    console.log(`${colors.bold}Starting test execution...${colors.reset}`);
+    console.log(`${colors.bold}Total test suites: ${tests.length}${colors.reset}`);
+    console.log('');
+    console.log(`${colors.cyan}📋 Test Suite Overview:${colors.reset}`);
+    console.log(`${colors.cyan}• Basic Tests: Jest, Connection, Simple, Minimal, Working${colors.reset}`);
+    console.log(`${colors.cyan}• Security Tests: Authentication, Authorization, Vulnerability${colors.reset}`);
+    console.log(`${colors.cyan}• Performance Tests: Response Time, Memory, Scalability${colors.reset}`);
+    console.log(`${colors.cyan}• Edge Cases: Boundary Conditions, Error Handling${colors.reset}`);
+    console.log(`${colors.cyan}• Service Tests: ProcessService, DimensionService, CubeService, RestService, SubsetService${colors.reset}`);
+    console.log(`${colors.cyan}• Coverage: Code Coverage Analysis${colors.reset}`);
+    console.log('');
+    
+    // Run tests sequentially to avoid conflicts
+    for (const test of tests) {
+        await runTest(test);
+    }
+    
+    printSummary();
+    
+    // Exit with appropriate code
+    process.exit(failedTests > 0 ? 1 : 0);
+}
+
+// Handle interruption
+process.on('SIGINT', () => {
+    console.log(`\n${colors.yellow}Test execution interrupted by user.${colors.reset}`);
+    printSummary();
+    process.exit(130);
+});
+
+// Run if called directly
+if (require.main === module) {
+    runAllTests().catch((error) => {
+        console.error(`${colors.red}Fatal error:${colors.reset}`, error);
+        process.exit(1);
+    });
+}
+
+module.exports = { runAllTests };

package/src/exceptions/TM1Exception.ts

@@ -0,0 +1,38 @@
+export class TM1Exception extends Error {
+    public response?: any;
+    public statusCode?: number;
+
+    constructor(message: string, response?: any) {
+        super(message);
+        this.name = 'TM1Exception';
+        this.response = response;
+        this.statusCode = response?.status;
+    }
+}
+
+export class TM1RestException extends TM1Exception {
+    public status?: number;
+    
+    constructor(message: string, status?: number, response?: any) {
+        super(message, response);
+        this.name = 'TM1RestException';
+        this.status = status;
+    }
+}
+
+export class TM1TimeoutException extends TM1Exception {
+    public timeout: number;
+    
+    constructor(message: string, timeout: number = 0) {
+        super(message);
+        this.name = 'TM1TimeoutException';
+        this.timeout = timeout;
+    }
+}
+
+export class TM1VersionDeprecationException extends TM1Exception {
+    constructor(message: string) {
+        super(message);
+        this.name = 'TM1VersionDeprecationException';
+    }
+}

package/src/exceptions/TM1RestException.ts

@@ -0,0 +1,17 @@
+/**
+ * Exception for REST API related errors
+ */
+
+import { TM1Exception } from './TM1Exception';
+
+export class TM1RestException extends TM1Exception {
+    public status?: number;
+    public response?: any;
+
+    constructor(message: string, status?: number, response?: any) {
+        super(message);
+        this.name = 'TM1RestException';
+        this.status = status;
+        this.response = response;
+    }
+}

package/src/exceptions/TM1TimeoutException.ts

@@ -0,0 +1,15 @@
+/**
+ * Exception for timeout related errors
+ */
+
+import { TM1Exception } from './TM1Exception';
+
+export class TM1TimeoutException extends TM1Exception {
+    public timeout: number;
+
+    constructor(message: string, timeout: number = 0) {
+        super(message);
+        this.name = 'TM1TimeoutException';
+        this.timeout = timeout;
+    }
+}

package/src/index.ts

@@ -0,0 +1,94 @@
+// Core service exports
+export { TM1Service } from './services/TM1Service';
+export { RestService, AuthenticationMode } from './services/RestService';
+export { DimensionService } from './services/DimensionService';
+export { HierarchyService } from './services/HierarchyService';
+export { SubsetService } from './services/SubsetService';
+export { ObjectService } from './services/ObjectService';
+
+// Additional services from index
+export {
+    CubeService,
+    ElementService,
+    CellService,
+    ProcessService,
+    ViewService,
+    SecurityService,
+    FileService,
+    SessionService,
+    ConfigurationService,
+    ServerService,
+    MonitoringService,
+    AnnotationService,
+    ApplicationService,
+    AuditLogService,
+    ChoreService,
+    GitService,
+    JobService,
+    LoggerService,
+    ManageService,
+    MessageLogService,
+    PowerBiService,
+    SandboxService,
+    ThreadService,
+    TransactionLogService,
+    UserService
+} from './services';
+
+// Object exports
+export { TM1Object } from './objects/TM1Object';
+export { Dimension } from './objects/Dimension';
+export { Hierarchy } from './objects/Hierarchy';
+export { Element, ElementType } from './objects/Element';
+export { ElementAttribute, ElementAttributeType } from './objects/ElementAttribute';
+
+// Additional object exports
+export { Annotation } from './objects/Annotation';
+export { Application } from './objects/Application';
+export { Chore } from './objects/Chore';
+export { ChoreFrequency } from './objects/ChoreFrequency';
+export { ChoreStartTime } from './objects/ChoreStartTime';
+export { ChoreTask, ChoreTaskParameter } from './objects/ChoreTask';
+export { Cube } from './objects/Cube';
+export { Git } from './objects/Git';
+export { GitCommit } from './objects/GitCommit';
+export { GitPlan, GitPushPlan, GitPullPlan } from './objects/GitPlan';
+export { GitRemote } from './objects/GitRemote';
+export { Process } from './objects/Process';
+export { ProcessDebugBreakpoint, HitMode, BreakPointType } from './objects/ProcessDebugBreakpoint';
+export { Rules } from './objects/Rules';
+export { Sandbox } from './objects/Sandbox';
+export { Server } from './objects/Server';
+export { Subset, AnonymousSubset } from './objects/Subset';
+export { TM1Project, TM1ProjectTask, TM1ProjectDeployment } from './objects/TM1Project';
+export { User } from './objects/User';
+export { View, MDXView, NativeView } from './objects/View';
+export { ViewAxisSelection, ViewTitleSelection } from './objects/Axis';
+
+// Enum exports
+export { LogLevel } from './services/ServerService';
+
+// Exception exports
+export { 
+    TM1Exception,
+    TM1RestException,
+    TM1TimeoutException,
+    TM1VersionDeprecationException
+} from './exceptions/TM1Exception';
+
+// Utility exports
+export { Utils } from './utils/Utils';
+export {
+    CaseAndSpaceInsensitiveMap,
+    CaseAndSpaceInsensitiveSet,
+    caseAndSpaceInsensitiveEquals,
+    lowerAndDropSpaces,
+    formatUrl
+} from './utils/Utils';
+
+// Type exports
+export type { RestServiceConfig } from './services/RestService';
+export type { DatabaseResourceConfig } from './services/ManageService';
+
+// Version
+export const version = '2.1.0';

package/src/objects/Annotation.ts

@@ -0,0 +1,194 @@
+import { TM1Object } from './TM1Object';
+import { formatUrl } from '../utils/Utils';
+
+export class Annotation extends TM1Object {
+    /** Abstraction of TM1 Annotation
+     *
+     *     :Notes:
+     *         - Class complete, functional and tested.
+     *         - doesn't cover Attachments though
+     */
+
+    private _id?: string;
+    private _text: string;
+    private _creator?: string;
+    private _created?: string;
+    private _lastUpdatedBy?: string;
+    private _lastUpdated?: string;
+    private _dimensionalContext: string[];
+    private _commentType: string;
+    private _commentValue: string;
+    private _objectName: string;
+
+    constructor(
+        commentValue: string,
+        objectName: string,
+        dimensionalContext: Iterable<string>,
+        commentType: string = 'ANNOTATION',
+        annotationId?: string,
+        text: string = '',
+        creator?: string,
+        created?: string,
+        lastUpdatedBy?: string,
+        lastUpdated?: string
+    ) {
+        super();
+        this._id = annotationId;
+        this._text = text;
+        this._creator = creator;
+        this._created = created;
+        this._lastUpdatedBy = lastUpdatedBy;
+        this._lastUpdated = lastUpdated;
+        this._dimensionalContext = Array.from(dimensionalContext);
+        this._commentType = commentType;
+        this._commentValue = commentValue;
+        this._objectName = objectName;
+    }
+
+    public static fromJSON(annotationAsJson: string): Annotation {
+        /** Alternative constructor
+         *
+         *     :param annotation_as_json: String, JSON
+         *     :return: instance of .Process
+         */
+        const annotationAsDict = JSON.parse(annotationAsJson);
+        const annotationId = annotationAsDict.ID;
+        const text = annotationAsDict.Text;
+        const creator = annotationAsDict.Creator;
+        const created = annotationAsDict.Created;
+        const lastUpdatedBy = annotationAsDict.LastUpdatedBy;
+        const lastUpdated = annotationAsDict.LastUpdated;
+        const dimensionalContext = annotationAsDict.DimensionalContext.map((item: any) => item.Name);
+        const commentType = annotationAsDict.commentType;
+        const commentValue = annotationAsDict.commentValue;
+        const objectName = annotationAsDict.objectName;
+        
+        return new Annotation(
+            commentValue,
+            objectName,
+            dimensionalContext,
+            commentType,
+            annotationId,
+            text,
+            creator,
+            created,
+            lastUpdatedBy,
+            lastUpdated
+        );
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.constructBody());
+    }
+
+    public get bodyAsDict(): any {
+        return this.constructBody();
+    }
+
+    public get commentValue(): string {
+        return this._commentValue;
+    }
+
+    public set commentValue(value: string) {
+        this._commentValue = value;
+    }
+
+    public get text(): string {
+        return this._text;
+    }
+
+    public get dimensionalContext(): string[] {
+        return this._dimensionalContext;
+    }
+
+    public get created(): string | undefined {
+        return this._created;
+    }
+
+    public get objectName(): string {
+        return this._objectName;
+    }
+
+    public get lastUpdated(): string | undefined {
+        return this._lastUpdated;
+    }
+
+    public get lastUpdatedBy(): string | undefined {
+        return this._lastUpdatedBy;
+    }
+
+    public get id(): string | undefined {
+        return this._id;
+    }
+
+    public move(
+        dimensionOrder: Iterable<string>,
+        dimension: string,
+        targetElement: string,
+        sourceElement?: string
+    ): void {
+        /** Move annotation on given dimension from source_element to target_element
+         * 
+         *     :param dimension_order: List, order of the dimensions in the cube
+         *     :param dimension: dimension name
+         *     :param target_element: target element name
+         *     :param source_element:  source element name
+         *     :return: 
+         */
+        const dimensionOrderArray = Array.from(dimensionOrder);
+        for (let i = 0; i < dimensionOrderArray.length; i++) {
+            const dimensionName = dimensionOrderArray[i];
+            if (dimensionName.toLowerCase() === dimension.toLowerCase()) {
+                if (!sourceElement || this._dimensionalContext[i] === sourceElement) {
+                    this._dimensionalContext[i] = targetElement;
+                }
+            }
+        }
+    }
+
+    private constructBody(): any {
+        /** construct the ODATA conform JSON representation for the Annotation entity.
+         *
+         *     :return: string, the valid JSON
+         */
+        const dimensionalContext = this._dimensionalContext.map(element => ({ Name: element }));
+        const body: any = {};
+        body.ID = this._id;
+        body.Text = this._text;
+        body.Creator = this._creator;
+        body.Created = this._created;
+        body.LastUpdatedBy = this._lastUpdatedBy;
+        body.LastUpdated = this._lastUpdated;
+        body.DimensionalContext = dimensionalContext;
+        const commentLocations = this._dimensionalContext.join(',');
+        body.commentLocation = commentLocations.substring(1);
+        body.commentType = this._commentType;
+        body.commentValue = this._commentValue;
+        body.objectName = this._objectName;
+        return body;
+    }
+
+    public constructBodyForPost(cubeDimensions: string[]): any {
+        const body: any = {};
+        body.Text = this.text;
+        body.ApplicationContext = [{
+            "Facet@odata.bind": "ApplicationContextFacets('}Cubes')",
+            "Value": this.objectName
+        }];
+        body["DimensionalContext@odata.bind"] = [];
+
+        for (let i = 0; i < cubeDimensions.length; i++) {
+            const dimension = cubeDimensions[i];
+            const element = this.dimensionalContext[i];
+            const coordinates = formatUrl("Dimensions('{}')/Hierarchies('{}')/Members('{}')", dimension, dimension, element);
+            body["DimensionalContext@odata.bind"].push(coordinates);
+        }
+
+        body.objectName = this.objectName;
+        body.commentValue = this.commentValue;
+        body.commentType = 'ANNOTATION';
+        body.commentLocation = this.dimensionalContext.join(',');
+
+        return body;
+    }
+}