@originals/sdk 1.4.2 → 1.4.3

package/tests/performance/logging.perf.test.ts

@@ -1,336 +0,0 @@
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { Logger, type LogOutput, type LogEntry } from '../../src/utils/Logger';
-import { MetricsCollector } from '../../src/utils/MetricsCollector';
-import { EventLogger } from '../../src/utils/EventLogger';
-import { EventEmitter } from '../../src/events/EventEmitter';
-import type { OriginalsConfig, AssetCreatedEvent } from '../../src/types';
-
-describe('Logging Performance Benchmarks', () => {
-  let config: OriginalsConfig;
-  let noOpOutput: LogOutput;
-  
-  beforeEach(() => {
-    noOpOutput = {
-      write: () => {} // No-op for performance testing
-    };
-    
-    config = {
-      network: 'mainnet',
-      defaultKeyType: 'ES256K',
-      logging: {
-        level: 'info',
-        outputs: [noOpOutput]
-      }
-    };
-  });
-  
-  describe('Logger performance', () => {
-    test('should log with <1ms overhead per call', () => {
-      const logger = new Logger('Test', config);
-      
-      const iterations = 1000;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        logger.info('Test message', { iteration: i });
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / iterations;
-      
-      console.log(`Logger average time per call: ${avgDuration.toFixed(3)}ms`);
-      
-      expect(avgDuration).toBeLessThan(1);
-    });
-    
-    test('should handle child logger creation efficiently', () => {
-      const logger = new Logger('Test', config);
-      
-      const iterations = 1000;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        const child = logger.child(`Child${i}`);
-        child.info('Test message');
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / iterations;
-      
-      console.log(`Child logger + log average time: ${avgDuration.toFixed(3)}ms`);
-      
-      expect(avgDuration).toBeLessThan(2);
-    });
-    
-    test('should handle timer operations efficiently', () => {
-      const logger = new Logger('Test', config);
-      config.logging!.level = 'debug'; // Enable debug to see timer logs
-      
-      const iterations = 1000;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        const stopTimer = logger.startTimer(`operation${i}`);
-        stopTimer();
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / iterations;
-      
-      console.log(`Timer operation average time: ${avgDuration.toFixed(3)}ms`);
-      
-      expect(avgDuration).toBeLessThan(1);
-    });
-    
-    test('should filter log levels efficiently', () => {
-      const logger = new Logger('Test', config);
-      config.logging!.level = 'error'; // High threshold
-      
-      const iterations = 10000;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        logger.debug('Debug message'); // Should be filtered
-        logger.info('Info message');   // Should be filtered
-        logger.warn('Warn message');   // Should be filtered
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / (iterations * 3);
-      
-      console.log(`Filtered log average time: ${avgDuration.toFixed(3)}ms`);
-      
-      // Filtered logs should be even faster
-      expect(avgDuration).toBeLessThan(0.1);
-    });
-  });
-  
-  describe('MetricsCollector performance', () => {
-    test('should record operations efficiently', () => {
-      const metrics = new MetricsCollector();
-      
-      const iterations = 10000;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        metrics.recordOperation('testOp', Math.random() * 100, true);
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / iterations;
-      
-      console.log(`MetricsCollector record average time: ${avgDuration.toFixed(3)}ms`);
-      
-      expect(avgDuration).toBeLessThan(0.1);
-    });
-    
-    test('should handle concurrent metric types efficiently', () => {
-      const metrics = new MetricsCollector();
-      
-      const iterations = 1000;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        metrics.recordAssetCreated();
-        metrics.recordMigration('did:peer', 'did:webvh');
-        metrics.recordTransfer();
-        metrics.recordError('ERR_001');
-        metrics.recordCacheHit();
-        metrics.recordCacheMiss();
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / (iterations * 6);
-      
-      console.log(`Multiple metric types average time: ${avgDuration.toFixed(3)}ms`);
-      
-      expect(avgDuration).toBeLessThan(0.1);
-    });
-    
-    test('should export large metric sets efficiently', () => {
-      const metrics = new MetricsCollector();
-      
-      // Generate large metric set
-      for (let i = 0; i < 1000; i++) {
-        metrics.recordOperation(`op${i % 10}`, Math.random() * 100, true);
-        metrics.recordAssetCreated();
-        metrics.recordMigration('did:peer', 'did:webvh');
-      }
-      
-      // Test JSON export
-      const jsonStart = performance.now();
-      const json = metrics.export('json');
-      const jsonDuration = performance.now() - jsonStart;
-      
-      console.log(`JSON export time: ${jsonDuration.toFixed(3)}ms`);
-      
-      expect(jsonDuration).toBeLessThan(50);
-      
-      // Test Prometheus export
-      const promStart = performance.now();
-      const prom = metrics.export('prometheus');
-      const promDuration = performance.now() - promStart;
-      
-      console.log(`Prometheus export time: ${promDuration.toFixed(3)}ms`);
-      
-      expect(promDuration).toBeLessThan(100);
-    });
-  });
-  
-  describe('EventLogger performance', () => {
-    test('should handle event logging with <0.5ms overhead', async () => {
-      const logger = new Logger('Test', config);
-      const metrics = new MetricsCollector();
-      const eventLogger = new EventLogger(logger, metrics);
-      const eventEmitter = new EventEmitter();
-      
-      eventLogger.subscribeToEvents(eventEmitter);
-      
-      const event: AssetCreatedEvent = {
-        type: 'asset:created',
-        timestamp: new Date().toISOString(),
-        asset: {
-          id: 'did:peer:test123',
-          layer: 'did:peer',
-          resourceCount: 1,
-          createdAt: new Date().toISOString()
-        }
-      };
-      
-      const iterations = 100;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        await eventEmitter.emit(event);
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / iterations;
-      
-      console.log(`EventLogger average time per event: ${avgDuration.toFixed(3)}ms`);
-      
-      expect(avgDuration).toBeLessThan(0.5);
-    });
-  });
-  
-  describe('Memory efficiency', () => {
-    test('should not leak memory with many log calls', () => {
-      const logger = new Logger('Test', config);
-      
-      // Create a buffer to store some references
-      const beforeMemory = (process as any).memoryUsage?.() || { heapUsed: 0 };
-      
-      for (let i = 0; i < 10000; i++) {
-        logger.info('Test message', { 
-          iteration: i,
-          data: { key: 'value', nested: { deep: 'data' } }
-        });
-      }
-      
-      // Force garbage collection if available
-      if (global.gc) {
-        global.gc();
-      }
-      
-      const afterMemory = (process as any).memoryUsage?.() || { heapUsed: 0 };
-      
-      // Memory increase should be minimal (less than 10MB)
-      const memoryIncrease = (afterMemory.heapUsed - beforeMemory.heapUsed) / 1024 / 1024;
-      
-      console.log(`Memory increase after 10k logs: ${memoryIncrease.toFixed(2)}MB`);
-      
-      expect(memoryIncrease).toBeLessThan(10);
-    });
-    
-    test('should not leak memory in metrics collection', () => {
-      const metrics = new MetricsCollector();
-      
-      const beforeMemory = (process as any).memoryUsage?.() || { heapUsed: 0 };
-      
-      // Record many operations
-      for (let i = 0; i < 50000; i++) {
-        metrics.recordOperation(`op${i % 20}`, Math.random() * 100, true);
-      }
-      
-      if (global.gc) {
-        global.gc();
-      }
-      
-      const afterMemory = (process as any).memoryUsage?.() || { heapUsed: 0 };
-      
-      const memoryIncrease = (afterMemory.heapUsed - beforeMemory.heapUsed) / 1024 / 1024;
-      
-      console.log(`Memory increase after 50k metrics: ${memoryIncrease.toFixed(2)}MB`);
-      
-      // Should only store aggregated data for 20 operations, not 50k entries
-      expect(memoryIncrease).toBeLessThan(5);
-    });
-  });
-  
-  describe('Sanitization performance', () => {
-    test('should sanitize data efficiently', () => {
-      config.logging!.sanitizeLogs = true;
-      const logger = new Logger('Test', config);
-      
-      const sensitiveData = {
-        username: 'alice',
-        privateKey: 'z6Mk...',
-        publicKey: 'z6Mk...',
-        data: {
-          nested: {
-            secret: 'top-secret',
-            password: 'password123'
-          }
-        }
-      };
-      
-      const iterations = 1000;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        logger.info('User data', sensitiveData);
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / iterations;
-      
-      console.log(`Sanitization average time: ${avgDuration.toFixed(3)}ms`);
-      
-      // Sanitization should add minimal overhead
-      expect(avgDuration).toBeLessThan(2);
-    });
-  });
-  
-  describe('Overall telemetry impact', () => {
-    test('should have minimal impact on SDK operations', async () => {
-      const logger = new Logger('SDK', config);
-      const metrics = new MetricsCollector();
-      
-      // Simulate SDK operation with full logging
-      const iterations = 100;
-      const start = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        const childLogger = logger.child('Operation');
-        const stopTimer = childLogger.startTimer('fullOperation');
-        
-        childLogger.info('Starting operation', { iteration: i });
-        
-        // Simulate work
-        metrics.recordOperation('work', Math.random() * 10, true);
-        
-        childLogger.info('Operation completed', { iteration: i });
-        stopTimer();
-      }
-      
-      const duration = performance.now() - start;
-      const avgDuration = duration / iterations;
-      
-      console.log(`Full telemetry stack average time: ${avgDuration.toFixed(3)}ms`);
-      
-      // Total overhead should be less than 2ms per operation
-      expect(avgDuration).toBeLessThan(2);
-    });
-  });
-});
-

package/tests/sdk.test.ts

@@ -1,43 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { OriginalsSDK } from '../src/index';
-import { validateDID, validateCredential } from '../src/utils/validation';
-
-describe('OriginalsSDK', () => {
-  test('should create SDK instance', () => {
-    const sdk = OriginalsSDK.create();
-    expect(sdk).toBeInstanceOf(OriginalsSDK);
-    expect(sdk.did).toBeDefined();
-    expect(sdk.credentials).toBeDefined();
-    expect(sdk.lifecycle).toBeDefined();
-    expect(sdk.bitcoin).toBeDefined();
-  });
-
-  test('should validate DIDs correctly', () => {
-    expect(validateDID('did:peer:123456')).toBe(true);
-    expect(validateDID('did:webvh:example.com:123')).toBe(true);
-    expect(validateDID('did:btco:1234567890abcdef')).toBe(true);
-    expect(validateDID('invalid-did')).toBe(false);
-    expect(validateDID('did:web:example.com')).toBe(false); // wrong method
-  });
-
-  test('should validate layer transitions', () => {
-    // Test cases for valid layer transitions
-    const validTransitions = [
-      ['did:peer', 'did:webvh'],
-      ['did:peer', 'did:btco'],
-      ['did:webvh', 'did:btco']
-    ];
-
-    const invalidTransitions = [
-      ['did:webvh', 'did:peer'],
-      ['did:btco', 'did:peer'],
-      ['did:btco', 'did:webvh']
-    ];
-
-    // These would be tested with actual implementation
-    expect(validTransitions.length).toBe(3);
-    expect(invalidTransitions.length).toBe(3);
-  });
-});
-
-