@originals/sdk 1.2.0 → 1.4.3

package/tests/integration/TelemetryIntegration.test.ts

@@ -1,395 +0,0 @@
-import { describe, test, expect, beforeEach, mock } from 'bun:test';
-import { OriginalsSDK } from '../../src/core/OriginalsSDK';
-import type { OriginalsConfig } from '../../src/types';
-import type { LogOutput, LogEntry } from '../../src/utils/Logger';
-
-describe('Telemetry Integration', () => {
-  let logEntries: LogEntry[];
-  let mockOutput: LogOutput;
-  let config: OriginalsConfig;
-  
-  beforeEach(() => {
-    logEntries = [];
-    mockOutput = {
-      write: (entry: LogEntry) => {
-        logEntries.push(entry);
-      }
-    };
-    
-    config = {
-      network: 'regtest',
-      defaultKeyType: 'ES256K',
-      logging: {
-        level: 'debug',
-        outputs: [mockOutput]
-      },
-      metrics: {
-        enabled: true
-      }
-    };
-  });
-  
-  describe('SDK initialization', () => {
-    test('should log SDK initialization', () => {
-      const sdk = new OriginalsSDK(config);
-      
-      // Should have logged initialization
-      const initLogs = logEntries.filter(e => e.message.includes('Initializing'));
-      expect(initLogs.length).toBeGreaterThan(0);
-      
-      const successLogs = logEntries.filter(e => e.message.includes('initialized successfully'));
-      expect(successLogs.length).toBeGreaterThan(0);
-    });
-    
-    test('should have logger and metrics accessible', () => {
-      const sdk = new OriginalsSDK(config);
-      
-      expect(sdk.logger).toBeDefined();
-      expect(sdk.metrics).toBeDefined();
-    });
-  });
-  
-  describe('lifecycle operations with logging', () => {
-    test('should log asset creation', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        logging: {
-          level: 'info',
-          outputs: [mockOutput]
-        }
-      });
-      
-      const resources = [
-        {
-          id: 'test-resource',
-          type: 'text',
-          contentType: 'text/plain',
-          hash: 'abc123',
-          content: 'Hello World'
-        }
-      ];
-      
-      logEntries = []; // Reset log entries
-      
-      const asset = await sdk.lifecycle.createAsset(resources);
-      
-      // Should have logged asset creation
-      const creationLogs = logEntries.filter(e => e.message.includes('Creating asset'));
-      expect(creationLogs.length).toBeGreaterThan(0);
-      
-      const successLogs = logEntries.filter(e => e.message.includes('Asset created successfully'));
-      expect(successLogs.length).toBeGreaterThan(0);
-      
-      // Check that metrics were recorded
-      const lifecycleMetrics = (sdk.lifecycle as any).metrics.getMetrics();
-      expect(lifecycleMetrics.assetsCreated).toBeGreaterThan(0);
-    });
-    
-    test('should log with performance timing', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        logging: {
-          level: 'debug',
-          outputs: [mockOutput]
-        }
-      });
-      
-      const resources = [
-        {
-          id: 'test-resource',
-          type: 'text',
-          contentType: 'text/plain',
-          hash: 'abc123',
-          content: 'Hello World'
-        }
-      ];
-      
-      logEntries = [];
-      
-      await sdk.lifecycle.createAsset(resources);
-      
-      // Should have logged with duration
-      const timedLogs = logEntries.filter(e => 
-        e.message.includes('completed') && e.duration !== undefined
-      );
-      expect(timedLogs.length).toBeGreaterThan(0);
-      
-      // Duration should be reasonable
-      const duration = timedLogs[0].duration!;
-      expect(duration).toBeGreaterThan(0);
-      expect(duration).toBeLessThan(10000); // Less than 10 seconds
-    });
-  });
-  
-  describe('event logging integration', () => {
-    test('should automatically log events', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        logging: {
-          level: 'info',
-          outputs: [mockOutput],
-          eventLogging: {
-            'asset:created': 'info'
-          }
-        }
-      });
-      
-      const resources = [
-        {
-          id: 'test-resource',
-          type: 'text',
-          contentType: 'text/plain',
-          hash: 'abc123',
-          content: 'Hello World'
-        }
-      ];
-      
-      logEntries = [];
-      
-      const asset = await sdk.lifecycle.createAsset(resources);
-      
-      // Wait for microtask (event is deferred)
-      await new Promise(resolve => setTimeout(resolve, 10));
-      
-      // Should have logged the asset:created event
-      const eventLogs = logEntries.filter(e => e.context.includes('Events'));
-      expect(eventLogs.length).toBeGreaterThan(0);
-    });
-  });
-  
-  describe('metrics collection', () => {
-    test('should collect metrics from lifecycle operations', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        metrics: {
-          enabled: true
-        }
-      });
-      
-      const resources = [
-        {
-          id: 'test-resource',
-          type: 'text',
-          contentType: 'text/plain',
-          hash: 'abc123',
-          content: 'Hello World'
-        }
-      ];
-      
-      await sdk.lifecycle.createAsset(resources);
-      await sdk.lifecycle.createAsset(resources);
-      
-      // Get metrics from LifecycleManager
-      const lifecycleMetrics = (sdk.lifecycle as any).metrics.getMetrics();
-      
-      expect(lifecycleMetrics.assetsCreated).toBe(2);
-    });
-    
-    test('should export metrics in JSON format', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K'
-      });
-      
-      const resources = [
-        {
-          id: 'test-resource',
-          type: 'text',
-          contentType: 'text/plain',
-          hash: 'abc123',
-          content: 'Hello World'
-        }
-      ];
-      
-      await sdk.lifecycle.createAsset(resources);
-      
-      const lifecycleMetrics = (sdk.lifecycle as any).metrics;
-      const json = lifecycleMetrics.export('json');
-      
-      expect(() => JSON.parse(json)).not.toThrow();
-      
-      const parsed = JSON.parse(json);
-      expect(parsed.assetsCreated).toBeGreaterThan(0);
-    });
-    
-    test('should export metrics in Prometheus format', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K'
-      });
-      
-      const resources = [
-        {
-          id: 'test-resource',
-          type: 'text',
-          contentType: 'text/plain',
-          hash: 'abc123',
-          content: 'Hello World'
-        }
-      ];
-      
-      await sdk.lifecycle.createAsset(resources);
-      
-      const lifecycleMetrics = (sdk.lifecycle as any).metrics;
-      const prometheus = lifecycleMetrics.export('prometheus');
-      
-      expect(prometheus).toContain('originals_assets_created_total');
-    });
-  });
-  
-  describe('error logging', () => {
-    test('should log errors during operations', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        logging: {
-          level: 'error',
-          outputs: [mockOutput]
-        }
-      });
-      
-      logEntries = [];
-      
-      // Try to create asset with invalid resources
-      try {
-        await sdk.lifecycle.createAsset([]);
-      } catch (error) {
-        // Expected to fail
-      }
-      
-      // Should have logged the error
-      const errorLogs = logEntries.filter(e => e.level === 'error');
-      expect(errorLogs.length).toBeGreaterThan(0);
-    });
-    
-    test('should record error metrics', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K'
-      });
-      
-      // Try to create asset with invalid resources
-      try {
-        await sdk.lifecycle.createAsset([]);
-      } catch (error) {
-        // Expected to fail
-      }
-      
-      const lifecycleMetrics = (sdk.lifecycle as any).metrics.getMetrics();
-      
-      // Should have recorded an error
-      expect(Object.keys(lifecycleMetrics.errors).length).toBeGreaterThan(0);
-    });
-  });
-  
-  describe('child loggers', () => {
-    test('should use hierarchical context in logs', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        logging: {
-          level: 'info',
-          outputs: [mockOutput]
-        }
-      });
-      
-      const childLogger = sdk.logger.child('TestModule');
-      
-      logEntries = [];
-      childLogger.info('Test message');
-      
-      expect(logEntries.length).toBe(1);
-      expect(logEntries[0].context).toBe('SDK:TestModule');
-    });
-  });
-  
-  describe('configuration options', () => {
-    test('should respect log level configuration', () => {
-      const sdk = new OriginalsSDK({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        logging: {
-          level: 'warn',
-          outputs: [mockOutput]
-        }
-      });
-      
-      logEntries = [];
-      
-      sdk.logger.debug('Debug message');
-      sdk.logger.info('Info message');
-      sdk.logger.warn('Warn message');
-      
-      // Only warn and above should be logged
-      expect(logEntries.length).toBe(1);
-      expect(logEntries[0].level).toBe('warn');
-    });
-    
-    test('should support custom event logging configuration', async () => {
-      const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        logging: {
-          level: 'info',
-          outputs: [mockOutput],
-          eventLogging: {
-            'asset:created': 'info',
-            'asset:migrated': false // Disable migration logging
-          }
-        }
-      });
-      
-      const resources = [
-        {
-          id: 'test-resource',
-          type: 'text',
-          contentType: 'text/plain',
-          hash: 'abc123',
-          content: 'Hello World'
-        }
-      ];
-      
-      logEntries = [];
-      
-      await sdk.lifecycle.createAsset(resources);
-      
-      // Wait for events
-      await new Promise(resolve => setTimeout(resolve, 10));
-      
-      // Should have logs (configuration doesn't crash)
-      expect(logEntries.length).toBeGreaterThan(0);
-    });
-  });
-  
-  describe('data sanitization', () => {
-    test('should sanitize sensitive data in logs', () => {
-      const sdk = new OriginalsSDK({
-        network: 'regtest',
-        defaultKeyType: 'ES256K',
-        logging: {
-          level: 'info',
-          outputs: [mockOutput],
-          sanitizeLogs: true
-        }
-      });
-      
-      logEntries = [];
-      
-      sdk.logger.info('User operation', {
-        username: 'alice',
-        privateKey: 'z6Mk...',
-        operation: 'create'
-      });
-      
-      expect(logEntries.length).toBe(1);
-      expect(logEntries[0].data.username).toBe('alice');
-      expect(logEntries[0].data.privateKey).toBe('[REDACTED]');
-      expect(logEntries[0].data.operation).toBe('create');
-    });
-  });
-});
-

package/tests/integration/WebVhPublish.test.ts

@@ -1,48 +0,0 @@
-/** Canonical test aggregator created by combine-tests script. */
-
-/** Inlined from WebVhPublish.integration.part.ts */
-import { describe, test, expect } from 'bun:test';
-import { OriginalsSDK } from '../../src';
-import { AssetResource } from '../../src/types';
-import { MockKeyStore } from '../mocks/MockKeyStore';
-
-describe('WebVH publish end-to-end', () => {
-  const keyStore = new MockKeyStore();
-  const sdk = OriginalsSDK.create({ network: 'regtest', keyStore });
-  const publisherDid = 'did:webvh:example.com:alice';
-
-  test('createAsset → publishToWeb yields did:webvh and provenance event', async () => {
-    const resources: AssetResource[] = [
-      { id: 'r1', type: 'data', contentType: 'text/plain', hash: 'abc123', content: 'hello' }
-    ];
-
-    const asset = await sdk.lifecycle.createAsset(resources);
-    const published = await sdk.lifecycle.publishToWeb(asset, publisherDid);
-    
-    // Asset migrated to did:webvh layer
-    expect(published.currentLayer).toBe('did:webvh');
-    expect(published.id.startsWith('did:peer:')).toBe(true);
-    
-    // Binding to publisher's did:webvh
-    const webBinding = (published as any).bindings?.['did:webvh'];
-    expect(typeof webBinding).toBe('string');
-    expect(webBinding).toBe(publisherDid);
-
-    const resolved = await sdk.did.resolveDID(webBinding!);
-    expect(resolved?.id).toBe(webBinding);
-
-    // Resources have DID-based URLs (not .well-known)
-    expect(Array.isArray(published.resources)).toBe(true);
-    for (const r of published.resources) {
-      expect(typeof r.url).toBe('string');
-      expect((r.url as string).startsWith(publisherDid)).toBe(true);
-      expect((r.url as string).includes('/resources/')).toBe(true);
-    }
-
-    // Credentials may or may not be attached (best-effort)
-    // If the publisher DID doesn't have keys, credentials won't be issued
-    // This is acceptable - the publish operation succeeds regardless
-    const creds = (published as any).credentials || [];
-    expect(Array.isArray(creds)).toBe(true);
-  });
-});

package/tests/integration/migration/peer-to-webvh.test.ts

@@ -1,172 +0,0 @@
-/**
- * Integration tests for peer → webvh migration
- */
-
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { OriginalsSDK } from '../../../src';
-import { MigrationManager } from '../../../src/migration';
-import { MigrationStateEnum } from '../../../src/migration/types';
-
-describe('Peer to WebVH Migration', () => {
-  let sdk: OriginalsSDK;
-  let migrationManager: MigrationManager;
-
-  beforeEach(() => {
-    // Reset singleton
-    MigrationManager.resetInstance();
-
-    // Create SDK instance
-    sdk = OriginalsSDK.create({
-      network: 'signet',
-      defaultKeyType: 'Ed25519'
-    });
-
-    // Initialize migration manager
-    migrationManager = MigrationManager.getInstance(
-      sdk['config'],
-      sdk.did,
-      sdk.credentials
-    );
-  });
-
-  test('should successfully migrate from peer to webvh', async () => {
-    // Create a peer DID
-    const resources = [
-      {
-        id: 'resource-1',
-        type: 'Image',
-        contentType: 'image/png',
-        hash: 'abc123',
-        content: 'test-content'
-      }
-    ];
-
-    const peerDid = await sdk.did.createDIDPeer(resources);
-
-    // Migrate to webvh
-    const result = await migrationManager.migrate({
-      sourceDid: peerDid.id,
-      targetLayer: 'webvh',
-      domain: 'example.com'
-    });
-
-    // Verify migration success
-    expect(result.success).toBe(true);
-    expect(result.state).toBe(MigrationStateEnum.COMPLETED);
-    expect(result.targetDid).toBeDefined();
-    expect(result.targetDid).toContain('did:webvh:');
-    expect(result.sourceDid).toBe(peerDid.id);
-
-    // Verify audit record was created
-    expect(result.auditRecord).toBeDefined();
-    expect(result.auditRecord.finalState).toBe(MigrationStateEnum.COMPLETED);
-    expect(result.auditRecord.errors).toHaveLength(0);
-  });
-
-  test('should fail migration with invalid domain', async () => {
-    const resources = [
-      {
-        id: 'resource-1',
-        type: 'Image',
-        contentType: 'image/png',
-        hash: 'abc123'
-      }
-    ];
-
-    const peerDid = await sdk.did.createDIDPeer(resources);
-
-    // Attempt migration without domain
-    const result = await migrationManager.migrate({
-      sourceDid: peerDid.id,
-      targetLayer: 'webvh'
-      // Missing domain
-    });
-
-    // Verify migration failed
-    expect(result.success).toBe(false);
-    expect(result.error).toBeDefined();
-    expect(result.error?.code).toBe('VALIDATION_FAILED');
-  });
-
-  test('should track migration state throughout process', async () => {
-    const resources = [
-      {
-        id: 'resource-1',
-        type: 'Image',
-        contentType: 'image/png',
-        hash: 'abc123'
-      }
-    ];
-
-    const peerDid = await sdk.did.createDIDPeer(resources);
-
-    // Start migration
-    const migrationPromise = migrationManager.migrate({
-      sourceDid: peerDid.id,
-      targetLayer: 'webvh',
-      domain: 'example.com'
-    });
-
-    const result = await migrationPromise;
-
-    // Check final state
-    const state = await migrationManager.getMigrationStatus(result.migrationId);
-    expect(state).toBeDefined();
-    expect(state.state).toBe(MigrationStateEnum.COMPLETED);
-    expect(state.progress).toBe(100);
-  });
-
-  test('should get migration history for DID', async () => {
-    const resources = [
-      {
-        id: 'resource-1',
-        type: 'Image',
-        contentType: 'image/png',
-        hash: 'abc123'
-      }
-    ];
-
-    const peerDid = await sdk.did.createDIDPeer(resources);
-
-    // Perform migration
-    await migrationManager.migrate({
-      sourceDid: peerDid.id,
-      targetLayer: 'webvh',
-      domain: 'example.com'
-    });
-
-    // Get migration history
-    const history = await migrationManager.getMigrationHistory(peerDid.id);
-
-    expect(history).toBeDefined();
-    expect(history.length).toBeGreaterThan(0);
-    expect(history[0].sourceDid).toBe(peerDid.id);
-    expect(history[0].targetLayer).toBe('webvh');
-  });
-
-  test('should estimate migration cost', async () => {
-    const resources = [
-      {
-        id: 'resource-1',
-        type: 'Image',
-        contentType: 'image/png',
-        hash: 'abc123'
-      }
-    ];
-
-    const peerDid = await sdk.did.createDIDPeer(resources);
-
-    // Estimate cost
-    const cost = await migrationManager.estimateMigrationCost(
-      peerDid.id,
-      'webvh'
-    );
-
-    expect(cost).toBeDefined();
-    expect(cost.totalCost).toBeDefined();
-    expect(cost.networkFees).toBeDefined();
-    expect(cost.storageCost).toBeDefined();
-    expect(cost.totalCost).toBeDefined();
-    expect(cost.currency).toBe('sats');
-  });
-});