@originals/sdk 1.1.0

package/tests/unit/lifecycle/ResourceVersioning.test.ts

@@ -0,0 +1,651 @@
+import { describe, test, expect, beforeEach, spyOn } from 'bun:test';
+import { OriginalsAsset } from '../../../src/lifecycle/OriginalsAsset';
+import { ResourceVersionManager } from '../../../src/lifecycle/ResourceVersioning';
+import { AssetResource, DIDDocument, VerifiableCredential, OriginalsConfig } from '../../../src/types';
+import { hashResource } from '../../../src/utils/validation';
+import { CredentialManager } from '../../../src/vc/CredentialManager';
+import { DIDManager } from '../../../src/did/DIDManager';
+
+function buildDid(id: string): DIDDocument {
+  return {
+    '@context': ['https://www.w3.org/ns/did/v1'],
+    id,
+    verificationMethod: [{
+      id: `${id}#key-0`,
+      type: 'Multikey',
+      controller: id,
+      publicKeyMultibase: 'z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK'
+    }]
+  };
+}
+
+const emptyCreds: VerifiableCredential[] = [];
+
+describe('ResourceVersionManager', () => {
+  let versionManager: ResourceVersionManager;
+
+  beforeEach(() => {
+    versionManager = new ResourceVersionManager();
+  });
+
+  test('adds first version of a resource', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain');
+    
+    const history = versionManager.getHistory('res1');
+    expect(history).not.toBeNull();
+    expect(history!.versions.length).toBe(1);
+    expect(history!.currentVersion.version).toBe(1);
+    expect(history!.currentVersion.hash).toBe('hash1');
+    expect(history!.currentVersion.previousVersionHash).toBeUndefined();
+  });
+
+  test('adds second version with previous hash link', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain');
+    versionManager.addVersion('res1', 'hash2', 'text/plain', 'hash1', 'Updated content');
+    
+    const history = versionManager.getHistory('res1');
+    expect(history!.versions.length).toBe(2);
+    expect(history!.currentVersion.version).toBe(2);
+    expect(history!.currentVersion.hash).toBe('hash2');
+    expect(history!.currentVersion.previousVersionHash).toBe('hash1');
+    expect(history!.currentVersion.changes).toBe('Updated content');
+  });
+
+  test('getVersion retrieves specific version', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain');
+    versionManager.addVersion('res1', 'hash2', 'text/plain', 'hash1');
+    
+    const v1 = versionManager.getVersion('res1', 1);
+    const v2 = versionManager.getVersion('res1', 2);
+    
+    expect(v1!.hash).toBe('hash1');
+    expect(v2!.hash).toBe('hash2');
+  });
+
+  test('getVersion returns null for invalid version', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain');
+    
+    expect(versionManager.getVersion('res1', 0)).toBeNull();
+    expect(versionManager.getVersion('res1', 2)).toBeNull();
+    expect(versionManager.getVersion('nonexistent', 1)).toBeNull();
+  });
+
+  test('getCurrentVersion returns latest version', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain');
+    versionManager.addVersion('res1', 'hash2', 'text/plain', 'hash1');
+    versionManager.addVersion('res1', 'hash3', 'text/plain', 'hash2');
+    
+    const current = versionManager.getCurrentVersion('res1');
+    expect(current!.version).toBe(3);
+    expect(current!.hash).toBe('hash3');
+  });
+
+  test('verifyChain validates correct version chain', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain');
+    versionManager.addVersion('res1', 'hash2', 'text/plain', 'hash1');
+    versionManager.addVersion('res1', 'hash3', 'text/plain', 'hash2');
+    
+    expect(versionManager.verifyChain('res1')).toBe(true);
+  });
+
+  test('verifyChain fails for broken chain', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain');
+    versionManager.addVersion('res1', 'hash2', 'text/plain', 'wronghash');
+    
+    expect(versionManager.verifyChain('res1')).toBe(false);
+  });
+
+  test('verifyChain fails if first version has previousVersionHash', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain', 'somehash');
+    
+    expect(versionManager.verifyChain('res1')).toBe(false);
+  });
+
+  test('toJSON serializes version data', () => {
+    versionManager.addVersion('res1', 'hash1', 'text/plain');
+    versionManager.addVersion('res2', 'hash2', 'image/png');
+    
+    const json = versionManager.toJSON();
+    expect(json).toHaveProperty('res1');
+    expect(json).toHaveProperty('res2');
+  });
+});
+
+describe('OriginalsAsset - Resource Versioning', () => {
+  test('creates asset with initial resource version 1', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'hello',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('hello', 'utf-8')),
+        version: 1,
+        createdAt: new Date().toISOString()
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    
+    expect(asset.resources.length).toBe(1);
+    expect(asset.resources[0].version).toBe(1);
+    expect(asset.resources[0].previousVersionHash).toBeUndefined();
+  });
+
+  test('addResourceVersion creates new version and preserves old', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'hello',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('hello', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    const newResource = asset.addResourceVersion('res1', 'hello world', 'text/plain', 'Added world');
+    
+    expect(asset.resources.length).toBe(2);
+    expect(newResource.version).toBe(2);
+    expect(newResource.previousVersionHash).toBe(resources[0].hash);
+    expect(newResource.hash).not.toBe(resources[0].hash);
+    
+    // Old version should still be accessible
+    const v1 = asset.getResourceVersion('res1', 1);
+    expect(v1).not.toBeNull();
+    expect(v1!.content).toBe('hello');
+  });
+
+  test('addResourceVersion throws error if content unchanged', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'hello',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('hello', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    
+    expect(() => {
+      asset.addResourceVersion('res1', 'hello', 'text/plain');
+    }).toThrow('Content unchanged');
+  });
+
+  test('addResourceVersion throws error if resource not found', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'hello',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('hello', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    
+    expect(() => {
+      asset.addResourceVersion('nonexistent', 'content', 'text/plain');
+    }).toThrow('Resource with id nonexistent not found');
+  });
+
+  test('getAllVersions returns all versions sorted', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    asset.addResourceVersion('res1', 'v2', 'text/plain');
+    asset.addResourceVersion('res1', 'v3', 'text/plain');
+    
+    const versions = asset.getAllVersions('res1');
+    expect(versions.length).toBe(3);
+    expect(versions[0].version || 1).toBe(1);
+    expect(versions[1].version).toBe(2);
+    expect(versions[2].version).toBe(3);
+  });
+
+  test('getResourceHistory returns complete history', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    asset.addResourceVersion('res1', 'v2', 'text/plain');
+    
+    const history = asset.getResourceHistory('res1');
+    expect(history).not.toBeNull();
+    expect(history!.resourceId).toBe('res1');
+    expect(history!.versions.length).toBe(2);
+    expect(history!.currentVersion.version).toBe(2);
+  });
+
+  test('version chain integrity is verifiable', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    asset.addResourceVersion('res1', 'v2', 'text/plain');
+    asset.addResourceVersion('res1', 'v3', 'text/plain');
+    
+    // Access internal version manager for testing
+    const history = asset.getResourceHistory('res1');
+    expect(history).not.toBeNull();
+    
+    // Verify chain manually
+    const versions = history!.versions;
+    expect(versions[0].previousVersionHash).toBeUndefined();
+    expect(versions[1].previousVersionHash).toBe(versions[0].hash);
+    expect(versions[2].previousVersionHash).toBe(versions[1].hash);
+  });
+
+  test('emits resource:version:created event', async () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    
+    let eventEmitted = false;
+    let capturedEvent: any = null;
+    
+    asset.on('resource:version:created', (event) => {
+      eventEmitted = true;
+      capturedEvent = event;
+    });
+    
+    asset.addResourceVersion('res1', 'v2', 'text/plain', 'Test changes');
+    
+    // Wait for microtask to complete
+    await new Promise(resolve => setImmediate(resolve));
+    
+    expect(eventEmitted).toBe(true);
+    expect(capturedEvent.type).toBe('resource:version:created');
+    expect(capturedEvent.asset.id).toBe(asset.id);
+    expect(capturedEvent.resource.id).toBe('res1');
+    expect(capturedEvent.resource.fromVersion).toBe(1);
+    expect(capturedEvent.resource.toVersion).toBe(2);
+    expect(capturedEvent.changes).toBe('Test changes');
+  });
+
+  test('provenance tracks resource updates', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    const v1Hash = resources[0].hash;
+    
+    asset.addResourceVersion('res1', 'v2', 'text/plain', 'First update');
+    asset.addResourceVersion('res1', 'v3', 'text/plain', 'Second update');
+    
+    const provenance = asset.getProvenance();
+    expect(provenance.resourceUpdates.length).toBe(2);
+    
+    const update1 = provenance.resourceUpdates[0];
+    expect(update1.resourceId).toBe('res1');
+    expect(update1.fromVersion).toBe(1);
+    expect(update1.toVersion).toBe(2);
+    expect(update1.fromHash).toBe(v1Hash);
+    expect(update1.changes).toBe('First update');
+    
+    const update2 = provenance.resourceUpdates[1];
+    expect(update2.fromVersion).toBe(2);
+    expect(update2.toVersion).toBe(3);
+    expect(update2.changes).toBe('Second update');
+  });
+
+  test('hash-based content addressing validated', () => {
+    const content1 = 'content 1';
+    const content2 = 'content 2';
+    const hash1 = hashResource(Buffer.from(content1, 'utf-8'));
+    const hash2 = hashResource(Buffer.from(content2, 'utf-8'));
+    
+    expect(hash1).not.toBe(hash2);
+    
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: content1,
+        contentType: 'text/plain',
+        hash: hash1
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    const newResource = asset.addResourceVersion('res1', content2, 'text/plain');
+    
+    expect(newResource.hash).toBe(hash2);
+    expect(newResource.hash).not.toBe(hash1);
+  });
+
+  test('versioning works with Buffer content', () => {
+    const buffer1 = Buffer.from('binary content 1', 'utf-8');
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'data',
+        contentType: 'application/octet-stream',
+        hash: hashResource(buffer1)
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    const buffer2 = Buffer.from('binary content 2', 'utf-8');
+    const newResource = asset.addResourceVersion('res1', buffer2, 'application/octet-stream');
+    
+    expect(newResource.version).toBe(2);
+    expect(newResource.hash).toBe(hashResource(buffer2));
+  });
+
+  test('versioning works across all layers (did:peer)', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    expect(asset.currentLayer).toBe('did:peer');
+    
+    const newResource = asset.addResourceVersion('res1', 'v2', 'text/plain');
+    expect(newResource.version).toBe(2);
+  });
+
+  test('versioning works across all layers (did:webvh)', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:webvh:example.com:xyz'), emptyCreds);
+    expect(asset.currentLayer).toBe('did:webvh');
+    
+    const newResource = asset.addResourceVersion('res1', 'v2', 'text/plain');
+    expect(newResource.version).toBe(2);
+  });
+
+  test('versioning works across all layers (did:btco)', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:btco:123'), emptyCreds);
+    expect(asset.currentLayer).toBe('did:btco');
+    
+    const newResource = asset.addResourceVersion('res1', 'v2', 'text/plain');
+    expect(newResource.version).toBe(2);
+  });
+
+  test('multiple resources can be versioned independently', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'res1-v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('res1-v1', 'utf-8'))
+      },
+      {
+        id: 'res2',
+        type: 'text',
+        content: 'res2-v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('res2-v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    
+    asset.addResourceVersion('res1', 'res1-v2', 'text/plain');
+    asset.addResourceVersion('res2', 'res2-v2', 'text/plain');
+    asset.addResourceVersion('res1', 'res1-v3', 'text/plain');
+    
+    const res1Versions = asset.getAllVersions('res1');
+    const res2Versions = asset.getAllVersions('res2');
+    
+    expect(res1Versions.length).toBe(3);
+    expect(res2Versions.length).toBe(2);
+  });
+
+  test('timestamp is recorded for each version', () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    const beforeTime = new Date().toISOString();
+    
+    const newResource = asset.addResourceVersion('res1', 'v2', 'text/plain');
+    const afterTime = new Date().toISOString();
+    
+    expect(newResource.createdAt).toBeDefined();
+    expect(newResource.createdAt! >= beforeTime).toBe(true);
+    expect(newResource.createdAt! <= afterTime).toBe(true);
+  });
+});
+
+describe('OriginalsAsset - Unsorted Resource Loading', () => {
+  test('handles unsorted resources correctly when loading persisted data', () => {
+    const hash1 = hashResource(Buffer.from('v1', 'utf-8'));
+    const hash2 = hashResource(Buffer.from('v2', 'utf-8'));
+    const hash3 = hashResource(Buffer.from('v3', 'utf-8'));
+    
+    // Simulate persisted resources loaded in wrong order [v3, v1, v2]
+    const unsortedResources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v3',
+        contentType: 'text/plain',
+        hash: hash3,
+        version: 3,
+        previousVersionHash: hash2,
+        createdAt: '2025-01-03T00:00:00Z'
+      },
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hash1,
+        version: 1,
+        createdAt: '2025-01-01T00:00:00Z'
+      },
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v2',
+        contentType: 'text/plain',
+        hash: hash2,
+        version: 2,
+        previousVersionHash: hash1,
+        createdAt: '2025-01-02T00:00:00Z'
+      }
+    ];
+    
+    const asset = new OriginalsAsset(unsortedResources, buildDid('did:peer:xyz'), emptyCreds);
+    
+    // Verify version history is correct despite unsorted input
+    const history = asset.getResourceHistory('res1');
+    expect(history).not.toBeNull();
+    expect(history!.versions.length).toBe(3);
+    
+    // Check versions are in correct order
+    expect(history!.versions[0].version).toBe(1);
+    expect(history!.versions[0].hash).toBe(hash1);
+    expect(history!.versions[0].previousVersionHash).toBeUndefined();
+    
+    expect(history!.versions[1].version).toBe(2);
+    expect(history!.versions[1].hash).toBe(hash2);
+    expect(history!.versions[1].previousVersionHash).toBe(hash1);
+    
+    expect(history!.versions[2].version).toBe(3);
+    expect(history!.versions[2].hash).toBe(hash3);
+    expect(history!.versions[2].previousVersionHash).toBe(hash2);
+    
+    // Current version should be v3
+    expect(history!.currentVersion.version).toBe(3);
+    expect(history!.currentVersion.hash).toBe(hash3);
+  });
+
+  test('handles multiple resources with unsorted versions', () => {
+    const res1_v1_hash = hashResource(Buffer.from('res1-v1', 'utf-8'));
+    const res1_v2_hash = hashResource(Buffer.from('res1-v2', 'utf-8'));
+    const res2_v1_hash = hashResource(Buffer.from('res2-v1', 'utf-8'));
+    const res2_v2_hash = hashResource(Buffer.from('res2-v2', 'utf-8'));
+    
+    // Multiple resources, each with unsorted versions
+    const resources: AssetResource[] = [
+      // res2 v2 (out of order)
+      {
+        id: 'res2',
+        type: 'text',
+        content: 'res2-v2',
+        contentType: 'text/plain',
+        hash: res2_v2_hash,
+        version: 2,
+        previousVersionHash: res2_v1_hash
+      },
+      // res1 v2 (out of order)
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'res1-v2',
+        contentType: 'text/plain',
+        hash: res1_v2_hash,
+        version: 2,
+        previousVersionHash: res1_v1_hash
+      },
+      // res2 v1
+      {
+        id: 'res2',
+        type: 'text',
+        content: 'res2-v1',
+        contentType: 'text/plain',
+        hash: res2_v1_hash,
+        version: 1
+      },
+      // res1 v1
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'res1-v1',
+        contentType: 'text/plain',
+        hash: res1_v1_hash,
+        version: 1
+      }
+    ];
+    
+    const asset = new OriginalsAsset(resources, buildDid('did:peer:xyz'), emptyCreds);
+    
+    // Verify both resources have correct version chains
+    const res1History = asset.getResourceHistory('res1');
+    expect(res1History!.versions[0].version).toBe(1);
+    expect(res1History!.versions[1].version).toBe(2);
+    expect(res1History!.versions[1].previousVersionHash).toBe(res1_v1_hash);
+    
+    const res2History = asset.getResourceHistory('res2');
+    expect(res2History!.versions[0].version).toBe(1);
+    expect(res2History!.versions[1].version).toBe(2);
+    expect(res2History!.versions[1].previousVersionHash).toBe(res2_v1_hash);
+  });
+});
+
+describe('OriginalsAsset - Credential Integration', () => {
+  test('credential can be issued for version creation (integration check)', async () => {
+    const resources: AssetResource[] = [
+      {
+        id: 'res1',
+        type: 'text',
+        content: 'v1',
+        contentType: 'text/plain',
+        hash: hashResource(Buffer.from('v1', 'utf-8'))
+      }
+    ];
+    
+    const didDoc = buildDid('did:peer:xyz');
+    const asset = new OriginalsAsset(resources, didDoc, emptyCreds);
+    
+    // Create credential manager
+    const config: OriginalsConfig = {
+      network: 'regtest',
+      defaultKeyType: 'ES256K'
+    };
+    const didManager = new DIDManager(config);
+    const credentialManager = new CredentialManager(config, didManager);
+    
+    // Issue a credential for resource update
+    const credential = await credentialManager.createResourceCredential(
+      'ResourceUpdated',
+      {
+        id: 'res1',
+        fromVersion: 1,
+        toVersion: 2,
+        timestamp: new Date().toISOString()
+      },
+      asset.id
+    );
+    
+    expect(credential.type).toContain('ResourceUpdated');
+    expect(credential.credentialSubject).toHaveProperty('fromVersion');
+    expect(credential.credentialSubject).toHaveProperty('toVersion');
+  });
+});