cim_summary/backend/test-serialization-only.js

// Test the SafeSerializer utility
require('ts-node/register');

// Import the SafeSerializer class from the agenticRAGProcessor
const { agenticRAGProcessor } = require('./src/services/agenticRAGProcessor');

// Access the SafeSerializer through the processor
const SafeSerializer = agenticRAGProcessor.constructor.prototype.SafeSerializer || 
                      (() => {
                        // If we can't access it directly, let's test with a simple implementation
                        class TestSafeSerializer {
                          static serialize(data) {
                            if (data === null || data === undefined) {
                              return null;
                            }
                            
                            if (typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean') {
                              return data;
                            }
                            
                            if (data instanceof Date) {
                              return data.toISOString();
                            }
                            
                            if (Array.isArray(data)) {
                              return data.map(item => this.serialize(item));
                            }
                            
                            if (typeof data === 'object') {
                              const seen = new WeakSet();
                              return this.serializeObject(data, seen);
                            }
                            
                            return String(data);
                          }
                          
                          static serializeObject(obj, seen) {
                            if (seen.has(obj)) {
                              return '[Circular Reference]';
                            }
                            
                            seen.add(obj);
                            
                            const result = {};
                            
                            for (const [key, value] of Object.entries(obj)) {
                              try {
                                if (typeof value === 'function' || typeof value === 'symbol') {
                                  continue;
                                }
                                
                                if (value === undefined) {
                                  continue;
                                }
                                
                                result[key] = this.serialize(value);
                              } catch (error) {
                                result[key] = '[Serialization Error]';
                              }
                            }
                            
                            return result;
                          }
                          
                          static safeStringify(data) {
                            try {
                              const serialized = this.serialize(data);
                              return JSON.stringify(serialized);
                            } catch (error) {
                              return JSON.stringify({ error: 'Serialization failed', originalType: typeof data });
                            }
                          }
                        }
                        return TestSafeSerializer;
                      })();

function testSerialization() {
  console.log('Testing SafeSerializer...');
  
  // Test 1: Simple data types
  console.log('\n1. Testing simple data types:');
  console.log('String:', SafeSerializer.serialize('test'));
  console.log('Number:', SafeSerializer.serialize(123));
  console.log('Boolean:', SafeSerializer.serialize(true));
  console.log('Null:', SafeSerializer.serialize(null));
  console.log('Undefined:', SafeSerializer.serialize(undefined));
  
  // Test 2: Date objects
  console.log('\n2. Testing Date objects:');
  const date = new Date();
  console.log('Date:', SafeSerializer.serialize(date));
  
  // Test 3: Arrays
  console.log('\n3. Testing arrays:');
  const array = [1, 'test', { key: 'value' }, [1, 2, 3]];
  console.log('Array:', SafeSerializer.serialize(array));
  
  // Test 4: Objects
  console.log('\n4. Testing objects:');
  const obj = {
    name: 'Test Object',
    value: 123,
    nested: {
      key: 'nested value',
      array: [1, 2, 3]
    },
    date: new Date()
  };
  console.log('Object:', SafeSerializer.serialize(obj));
  
  // Test 5: Circular references
  console.log('\n5. Testing circular references:');
  const circular = { name: 'circular' };
  circular.self = circular;
  console.log('Circular:', SafeSerializer.serialize(circular));
  
  // Test 6: Functions and symbols (should be skipped)
  console.log('\n6. Testing functions and symbols:');
  const withFunctions = {
    name: 'test',
    func: () => console.log('function'),
    symbol: Symbol('test'),
    valid: 'valid value'
  };
  console.log('With functions:', SafeSerializer.serialize(withFunctions));
  
  // Test 7: Complex nested structure
  console.log('\n7. Testing complex nested structure:');
  const complex = {
    company: {
      name: 'Restoration Systems Inc.',
      financials: {
        revenue: 50000000,
        ebitda: 10000000,
        metrics: [
          { year: 2023, revenue: 50000000, ebitda: 10000000 },
          { year: 2022, revenue: 42000000, ebitda: 8400000 }
        ]
      },
      analysis: {
        strengths: ['Market leader', 'Strong financials'],
        risks: ['Industry competition', 'Economic cycles']
      }
    },
    processing: {
      timestamp: new Date(),
      agents: ['document_understanding', 'financial_analysis', 'market_analysis'],
      status: 'completed'
    }
  };
  
  const serialized = SafeSerializer.serialize(complex);
  console.log('Complex object serialized successfully:', !!serialized);
  console.log('Keys in serialized object:', Object.keys(serialized));
  console.log('Company name preserved:', serialized.company?.name);
  console.log('Financial metrics count:', serialized.company?.financials?.metrics?.length);
  
  // Test 8: JSON stringify
  console.log('\n8. Testing safeStringify:');
  try {
    const jsonString = SafeSerializer.safeStringify(complex);
    console.log('JSON stringify successful, length:', jsonString.length);
    console.log('First 200 chars:', jsonString.substring(0, 200) + '...');
  } catch (error) {
    console.log('JSON stringify failed:', error.message);
  }
  
  console.log('\n✅ All serialization tests completed!');
}

testSerialization();