tm1npm 1.2.0 → 1.3.0

package/src/services/DebuggerService.ts

@@ -0,0 +1,399 @@
+import { ObjectService } from './ObjectService';
+import { RestService } from './RestService';
+import { formatUrl } from '../utils/Utils';
+
+/**
+ * Debug session information
+ */
+export interface DebugSession {
+    id: string;
+    processName: string;
+    status: 'Running' | 'Paused' | 'Completed' | 'Failed';
+    currentLine?: number;
+    variables?: { [key: string]: any };
+}
+
+/**
+ * Process variable information
+ */
+export interface ProcessVariable {
+    name: string;
+    value: any;
+    type: 'String' | 'Numeric' | 'Unknown';
+    scope: 'Local' | 'Global' | 'Parameter';
+}
+
+/**
+ * Call stack frame
+ */
+export interface CallStackFrame {
+    procedureName: string;
+    lineNumber: number;
+    source?: string;
+}
+
+/**
+ * Process validation result
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    errors: Array<{
+        line: number;
+        message: string;
+        severity: 'Error' | 'Warning';
+    }>;
+}
+
+/**
+ * DebuggerService - Comprehensive TM1 process debugging service
+ *
+ * Provides advanced debugging capabilities including session management,
+ * variable inspection, expression evaluation, and call stack analysis.
+ */
+export class DebuggerService extends ObjectService {
+    private activeSessions: Map<string, DebugSession> = new Map();
+
+    constructor(rest: RestService) {
+        super(rest);
+    }
+
+    /**
+     * Create a new debug session for a process
+     *
+     * @param processName - Name of the process to debug
+     * @returns Promise<string> - Debug session ID
+     *
+     * @example
+     * ```typescript
+     * const sessionId = await debuggerService.createDebugSession('MyProcess');
+     * ```
+     */
+    public async createDebugSession(processName: string): Promise<string> {
+        const url = formatUrl("/Processes('{}')/tm1.BeginDebug", processName);
+        const response = await this.rest.post(url, {});
+
+        const sessionId = response.data.ID || response.data.SessionId || this.generateSessionId();
+
+        // Track the session
+        this.activeSessions.set(sessionId, {
+            id: sessionId,
+            processName,
+            status: 'Paused',
+            currentLine: 0
+        });
+
+        return sessionId;
+    }
+
+    /**
+     * Terminate an active debug session
+     *
+     * @param sessionId - Debug session ID
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await debuggerService.terminateDebugSession(sessionId);
+     * ```
+     */
+    public async terminateDebugSession(sessionId: string): Promise<void> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/tm1.EndDebug", session.processName);
+
+        try {
+            await this.rest.post(url, {});
+        } finally {
+            this.activeSessions.delete(sessionId);
+        }
+    }
+
+    /**
+     * Step into the next line (enter function calls)
+     *
+     * @param sessionId - Debug session ID
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await debuggerService.stepInto(sessionId);
+     * ```
+     */
+    public async stepInto(sessionId: string): Promise<void> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/tm1.DebugStepIn", session.processName);
+        await this.rest.post(url, {});
+
+        session.status = 'Paused';
+        if (session.currentLine !== undefined) {
+            session.currentLine++;
+        }
+    }
+
+    /**
+     * Step over the next line (don't enter function calls)
+     *
+     * @param sessionId - Debug session ID
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await debuggerService.stepOver(sessionId);
+     * ```
+     */
+    public async stepOver(sessionId: string): Promise<void> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/tm1.DebugStepOver", session.processName);
+        await this.rest.post(url, {});
+
+        session.status = 'Paused';
+        if (session.currentLine !== undefined) {
+            session.currentLine++;
+        }
+    }
+
+    /**
+     * Step out of current function
+     *
+     * @param sessionId - Debug session ID
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await debuggerService.stepOut(sessionId);
+     * ```
+     */
+    public async stepOut(sessionId: string): Promise<void> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/tm1.DebugStepOut", session.processName);
+        await this.rest.post(url, {});
+
+        session.status = 'Paused';
+    }
+
+    /**
+     * Continue execution until next breakpoint or completion
+     *
+     * @param sessionId - Debug session ID
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await debuggerService.continueExecution(sessionId);
+     * ```
+     */
+    public async continueExecution(sessionId: string): Promise<void> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/tm1.DebugContinue", session.processName);
+        await this.rest.post(url, {});
+
+        session.status = 'Running';
+    }
+
+    /**
+     * Get all process variables in current debug session
+     *
+     * @param sessionId - Debug session ID
+     * @returns Promise<ProcessVariable[]> - Array of process variables
+     *
+     * @example
+     * ```typescript
+     * const variables = await debuggerService.getProcessVariables(sessionId);
+     * console.log(variables);
+     * ```
+     */
+    public async getProcessVariables(sessionId: string): Promise<ProcessVariable[]> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/Variables", session.processName);
+        const response = await this.rest.get(url);
+
+        const variables: ProcessVariable[] = [];
+
+        if (response.data.value) {
+            for (const variable of response.data.value) {
+                variables.push({
+                    name: variable.Name,
+                    value: variable.Value !== undefined ? variable.Value : null,
+                    type: variable.Type || 'Unknown',
+                    scope: variable.Scope || 'Local'
+                });
+            }
+        }
+
+        // Update session cache
+        session.variables = variables.reduce((acc, v) => {
+            acc[v.name] = v.value;
+            return acc;
+        }, {} as { [key: string]: any });
+
+        return variables;
+    }
+
+    /**
+     * Set a process variable value during debugging
+     *
+     * @param sessionId - Debug session ID
+     * @param variable - Variable name
+     * @param value - New value
+     * @returns Promise<void>
+     *
+     * @example
+     * ```typescript
+     * await debuggerService.setProcessVariable(sessionId, 'vCounter', 10);
+     * ```
+     */
+    public async setProcessVariable(
+        sessionId: string,
+        variable: string,
+        value: any
+    ): Promise<void> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/Variables('{}')", session.processName, variable);
+        await this.rest.patch(url, { Value: value });
+
+        // Update session cache
+        if (session.variables) {
+            session.variables[variable] = value;
+        }
+    }
+
+    /**
+     * Evaluate a TM1 expression in the debug context
+     *
+     * @param sessionId - Debug session ID
+     * @param expression - TM1 expression to evaluate
+     * @returns Promise<any> - Evaluation result
+     *
+     * @example
+     * ```typescript
+     * const result = await debuggerService.evaluateExpression(
+     *     sessionId,
+     *     'vCounter + 10'
+     * );
+     * console.log('Result:', result);
+     * ```
+     */
+    public async evaluateExpression(sessionId: string, expression: string): Promise<any> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/tm1.Evaluate", session.processName);
+        const response = await this.rest.post(url, { Expression: expression });
+
+        return response.data.Result !== undefined ? response.data.Result : response.data.value;
+    }
+
+    /**
+     * Get the current call stack
+     *
+     * @param sessionId - Debug session ID
+     * @returns Promise<CallStackFrame[]> - Call stack frames
+     *
+     * @example
+     * ```typescript
+     * const callStack = await debuggerService.getCallStack(sessionId);
+     * callStack.forEach(frame => {
+     *     console.log(`${frame.procedureName} at line ${frame.lineNumber}`);
+     * });
+     * ```
+     */
+    public async getCallStack(sessionId: string): Promise<CallStackFrame[]> {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Debug session ${sessionId} not found`);
+        }
+
+        const url = formatUrl("/Processes('{}')/tm1.GetCallStack", session.processName);
+
+        try {
+            const response = await this.rest.get(url);
+
+            if (response.data.value) {
+                return response.data.value.map((frame: any) => ({
+                    procedureName: frame.ProcedureName || frame.Name,
+                    lineNumber: frame.LineNumber || 0,
+                    source: frame.Source
+                }));
+            }
+        } catch (error: any) {
+            // If call stack API not available, return basic info
+            if (error.response?.status === 404) {
+                return [{
+                    procedureName: session.processName,
+                    lineNumber: session.currentLine || 0
+                }];
+            }
+            throw error;
+        }
+
+        return [];
+    }
+
+    /**
+     * Get debug session info
+     *
+     * @param sessionId - Debug session ID
+     * @returns DebugSession | undefined - Session information
+     *
+     * @example
+     * ```typescript
+     * const session = debuggerService.getSessionInfo(sessionId);
+     * console.log('Status:', session?.status);
+     * ```
+     */
+    public getSessionInfo(sessionId: string): DebugSession | undefined {
+        return this.activeSessions.get(sessionId);
+    }
+
+    /**
+     * List all active debug sessions
+     *
+     * @returns DebugSession[] - Array of active sessions
+     *
+     * @example
+     * ```typescript
+     * const sessions = debuggerService.listActiveSessions();
+     * console.log(`${sessions.length} active sessions`);
+     * ```
+     */
+    public listActiveSessions(): DebugSession[] {
+        return Array.from(this.activeSessions.values());
+    }
+
+    /**
+     * Generate a unique session ID
+     * @private
+     */
+    private generateSessionId(): string {
+        return `debug_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}

package/src/services/ProcessService.ts

@@ -686,4 +686,166 @@ export class ProcessService extends ObjectService {
             throw error;
         }
     }
+
+    /**
+     * Analyze process dependencies (what cubes/dimensions/processes it uses)
+     *
+     * @param processName - Name of the process
+     * @returns Promise<any> - Dependency information
+     *
+     * @example
+     * ```typescript
+     * const deps = await processService.analyzeProcessDependencies('ImportData');
+     * console.log('Cubes used:', deps.cubes);
+     * console.log('Dimensions used:', deps.dimensions);
+     * ```
+     */
+    public async analyzeProcessDependencies(processName: string): Promise<any> {
+        // Get process code
+        const process = await this.get(processName);
+
+        const dependencies = {
+            cubes: [] as string[],
+            dimensions: [] as string[],
+            processes: [] as string[],
+            subsets: [] as string[]
+        };
+
+        // Extract all code sections
+        const allCode = [
+            process.prologProcedure || '',
+            process.metadataProcedure || '',
+            process.dataProcedure || '',
+            process.epilogProcedure || ''
+        ].join('\n');
+
+        // Cube references (CellGetN, CellPutN, CubeExists, etc.)
+        const cubeMatches = allCode.match(/(?:CellGetN|CellPutN|CubeExists|CubeClear|CubeCreate|CubeDestroy)\s*\(\s*['"]([^'"]+)['"]/gi);
+        if (cubeMatches) {
+            cubeMatches.forEach(match => {
+                const cubeMatch = match.match(/['"]([^'"]+)['"]/);
+                if (cubeMatch && cubeMatch[1]) {
+                    if (!dependencies.cubes.includes(cubeMatch[1])) {
+                        dependencies.cubes.push(cubeMatch[1]);
+                    }
+                }
+            });
+        }
+
+        // Dimension references
+        const dimMatches = allCode.match(/(?:DimensionCreate|DimensionExists|DimIx)\s*\(\s*['"]([^'"]+)['"]/gi);
+        if (dimMatches) {
+            dimMatches.forEach(match => {
+                const dimMatch = match.match(/['"]([^'"]+)['"]/);
+                if (dimMatch && dimMatch[1]) {
+                    if (!dependencies.dimensions.includes(dimMatch[1])) {
+                        dependencies.dimensions.push(dimMatch[1]);
+                    }
+                }
+            });
+        }
+
+        // Process references (ExecuteProcess)
+        const processMatches = allCode.match(/ExecuteProcess\s*\(\s*['"]([^'"]+)['"]/gi);
+        if (processMatches) {
+            processMatches.forEach(match => {
+                const procMatch = match.match(/['"]([^'"]+)['"]/);
+                if (procMatch && procMatch[1]) {
+                    if (!dependencies.processes.includes(procMatch[1])) {
+                        dependencies.processes.push(procMatch[1]);
+                    }
+                }
+            });
+        }
+
+        return dependencies;
+    }
+
+    /**
+     * Validate process syntax without executing it
+     *
+     * @param processName - Name of the process
+     * @returns Promise<{isValid: boolean, errors: any[]}> - Validation result
+     *
+     * @example
+     * ```typescript
+     * const result = await processService.validateProcessSyntax('MyProcess');
+     * if (!result.isValid) {
+     *     console.error('Errors:', result.errors);
+     * }
+     * ```
+     */
+    public async validateProcessSyntax(processName: string): Promise<{isValid: boolean, errors: any[]}> {
+        try {
+            const result = await this.compileProcess(processName);
+            return {
+                isValid: result.success,
+                errors: result.errors.map((error, index) => ({
+                    line: index + 1,
+                    message: error,
+                    severity: 'Error'
+                }))
+            };
+        } catch (error: any) {
+            return {
+                isValid: false,
+                errors: [{
+                    line: 0,
+                    message: error.message || 'Validation failed',
+                    severity: 'Error'
+                }]
+            };
+        }
+    }
+
+    /**
+     * Get process execution plan (estimated resource usage)
+     *
+     * @param processName - Name of the process
+     * @returns Promise<any> - Execution plan information
+     *
+     * @example
+     * ```typescript
+     * const plan = await processService.getProcessExecutionPlan('ImportData');
+     * console.log('Estimated execution time:', plan.estimatedTime);
+     * ```
+     */
+    public async getProcessExecutionPlan(processName: string): Promise<any> {
+        const process = await this.get(processName);
+
+        // Analyze process characteristics
+        const plan = {
+            processName: process.name,
+            hasDataSource: !!(process as any).dataSource,
+            dataSourceType: (process as any).dataSource?.type || 'None',
+            hasParameters: process.parameters && process.parameters.length > 0,
+            parameterCount: process.parameters ? process.parameters.length : 0,
+            hasVariables: process.variables && process.variables.length > 0,
+            variableCount: process.variables ? process.variables.length : 0,
+            procedures: {
+                hasPrologProcedure: !!(process.prologProcedure && process.prologProcedure.trim()),
+                hasMetadataProcedure: !!(process.metadataProcedure && process.metadataProcedure.trim()),
+                hasDataProcedure: !!(process.dataProcedure && process.dataProcedure.trim()),
+                hasEpilogProcedure: !!(process.epilogProcedure && process.epilogProcedure.trim())
+            },
+            estimatedComplexity: 'Unknown'
+        };
+
+        // Estimate complexity
+        const totalCodeLength =
+            (process.prologProcedure?.length || 0) +
+            (process.metadataProcedure?.length || 0) +
+            (process.dataProcedure?.length || 0) +
+            (process.epilogProcedure?.length || 0);
+
+        if (totalCodeLength < 500) {
+            plan.estimatedComplexity = 'Low';
+        } else if (totalCodeLength < 2000) {
+            plan.estimatedComplexity = 'Medium';
+        } else {
+            plan.estimatedComplexity = 'High';
+        }
+
+        return plan;
+    }
 }

package/src/services/TM1Service.ts

@@ -3,6 +3,7 @@ import { DimensionService } from './DimensionService';
 import { HierarchyService } from './HierarchyService';
 import { SubsetService } from './SubsetService';
 import { DataFrameService } from './DataFrameService';
+import { DebuggerService } from './DebuggerService';
 import {
     CubeService,
     ElementService,
@@ -33,6 +34,7 @@ export class TM1Service {
     public files: FileService;
     public sessions: SessionService;
     public dataframes: DataFrameService;
+    public debugger: DebuggerService;
 
     constructor(config: RestServiceConfig) {
         this._tm1Rest = new RestService(config);
@@ -50,6 +52,7 @@ export class TM1Service {
         this.files = new FileService(this._tm1Rest);
         this.sessions = new SessionService(this._tm1Rest);
         this.dataframes = new DataFrameService(this._tm1Rest);
+        this.debugger = new DebuggerService(this._tm1Rest);
     }
 
     public async connect(): Promise<void> {

package/src/services/index.ts

@@ -11,6 +11,7 @@ export { ConfigurationService } from './ConfigurationService';
 export { ServerService } from './ServerService';
 export { MonitoringService } from './MonitoringService';
 export { DataFrameService } from './DataFrameService';
+export { DebuggerService } from './DebuggerService';
 
 // Additional services
 export { AnnotationService } from './AnnotationService';