@originals/sdk 1.4.2 → 1.4.3

package/tests/unit/storage/MemoryStorageAdapter.test.ts

@@ -1,93 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { MemoryStorageAdapter } from '../../../src/storage/MemoryStorageAdapter';
-
-describe('MemoryStorageAdapter', () => {
-  test('putObject stores string content', async () => {
-    const adapter = new MemoryStorageAdapter();
-    const uri = await adapter.putObject('example.com', '/test.txt', 'hello world');
-    expect(uri).toBe('mem://example.com/test.txt');
-  });
-
-  test('putObject stores Uint8Array content', async () => {
-    const adapter = new MemoryStorageAdapter();
-    const data = new Uint8Array([1, 2, 3, 4]);
-    const uri = await adapter.putObject('example.com', '/test.bin', data);
-    expect(uri).toBe('mem://example.com/test.bin');
-  });
-
-  test('getObject retrieves stored content', async () => {
-    const adapter = new MemoryStorageAdapter();
-    const data = new Uint8Array([5, 6, 7, 8]);
-    await adapter.putObject('example.com', '/data.bin', data);
-    
-    const result = await adapter.getObject('example.com', '/data.bin');
-    expect(result).not.toBeNull();
-    expect(result?.content).toEqual(data);
-  });
-
-  test('getObject returns null for non-existent object', async () => {
-    const adapter = new MemoryStorageAdapter();
-    const result = await adapter.getObject('example.com', '/nonexistent.txt');
-    expect(result).toBeNull();
-  });
-
-  test('exists returns true for stored object', async () => {
-    const adapter = new MemoryStorageAdapter();
-    await adapter.putObject('example.com', '/test.txt', 'content');
-    
-    const exists = await adapter.exists('example.com', '/test.txt');
-    expect(exists).toBe(true);
-  });
-
-  test('exists returns false for non-existent object', async () => {
-    const adapter = new MemoryStorageAdapter();
-    const exists = await adapter.exists('example.com', '/nonexistent.txt');
-    expect(exists).toBe(false);
-  });
-
-  test('putObject strips leading slashes from path', async () => {
-    const adapter = new MemoryStorageAdapter();
-    const uri = await adapter.putObject('example.com', '///test.txt', 'content');
-    expect(uri).toBe('mem://example.com/test.txt');
-    
-    const result = await adapter.getObject('example.com', '/test.txt');
-    expect(result).not.toBeNull();
-  });
-
-  test('getObject works with paths that have leading slashes', async () => {
-    const adapter = new MemoryStorageAdapter();
-    await adapter.putObject('example.com', 'test.txt', 'content');
-    
-    const result = await adapter.getObject('example.com', '/test.txt');
-    expect(result).not.toBeNull();
-  });
-
-  test('multiple domains are isolated', async () => {
-    const adapter = new MemoryStorageAdapter();
-    await adapter.putObject('domain1.com', '/test.txt', 'content1');
-    await adapter.putObject('domain2.com', '/test.txt', 'content2');
-    
-    const result1 = await adapter.getObject('domain1.com', '/test.txt');
-    const result2 = await adapter.getObject('domain2.com', '/test.txt');
-    
-    expect(new TextDecoder().decode(result1?.content)).toBe('content1');
-    expect(new TextDecoder().decode(result2?.content)).toBe('content2');
-  });
-
-  test('putObject overwrites existing content', async () => {
-    const adapter = new MemoryStorageAdapter();
-    await adapter.putObject('example.com', '/test.txt', 'original');
-    await adapter.putObject('example.com', '/test.txt', 'updated');
-    
-    const result = await adapter.getObject('example.com', '/test.txt');
-    expect(new TextDecoder().decode(result?.content)).toBe('updated');
-  });
-
-  test('exists handles paths with leading slashes', async () => {
-    const adapter = new MemoryStorageAdapter();
-    await adapter.putObject('example.com', 'test.txt', 'content');
-    
-    const exists = await adapter.exists('example.com', '/test.txt');
-    expect(exists).toBe(true);
-  });
-});

package/tests/unit/types/network.test.ts

@@ -1,255 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import {
-  WEBVH_NETWORKS,
-  DEFAULT_WEBVH_NETWORK,
-  getNetworkConfig,
-  getNetworkDomain,
-  getNetworkContextUrl,
-  validateVersionForNetwork,
-  getRecommendedNetworkForVersion,
-  getBitcoinNetworkForWebVH,
-  getWebVHNetworkForBitcoin,
-  type WebVHNetworkName,
-  type BitcoinNetworkName,
-} from '../../../src/types/network';
-
-describe('Network Configuration', () => {
-  describe('WEBVH_NETWORKS', () => {
-    it('should define all three networks', () => {
-      expect(WEBVH_NETWORKS.magby).toBeDefined();
-      expect(WEBVH_NETWORKS.cleffa).toBeDefined();
-      expect(WEBVH_NETWORKS.pichu).toBeDefined();
-    });
-
-    it('should have correct domains for each network', () => {
-      expect(WEBVH_NETWORKS.magby.domain).toBe('magby.originals.build');
-      expect(WEBVH_NETWORKS.cleffa.domain).toBe('cleffa.originals.build');
-      expect(WEBVH_NETWORKS.pichu.domain).toBe('pichu.originals.build');
-    });
-
-    it('should have correct stability levels', () => {
-      expect(WEBVH_NETWORKS.magby.stability).toBe('patch');
-      expect(WEBVH_NETWORKS.cleffa.stability).toBe('minor');
-      expect(WEBVH_NETWORKS.pichu.stability).toBe('major');
-    });
-
-    it('should have correct context URLs', () => {
-      expect(WEBVH_NETWORKS.magby.contextUrl).toBe('https://magby.originals.build/context');
-      expect(WEBVH_NETWORKS.cleffa.contextUrl).toBe('https://cleffa.originals.build/context');
-      expect(WEBVH_NETWORKS.pichu.contextUrl).toBe('https://pichu.originals.build/context');
-    });
-  });
-
-  describe('DEFAULT_WEBVH_NETWORK', () => {
-    it('should default to pichu (production)', () => {
-      expect(DEFAULT_WEBVH_NETWORK).toBe('pichu');
-    });
-  });
-
-  describe('getNetworkConfig', () => {
-    it('should return correct config for each network', () => {
-      const magbyConfig = getNetworkConfig('magby');
-      expect(magbyConfig.name).toBe('magby');
-      expect(magbyConfig.domain).toBe('magby.originals.build');
-
-      const cleffaConfig = getNetworkConfig('cleffa');
-      expect(cleffaConfig.name).toBe('cleffa');
-      expect(cleffaConfig.domain).toBe('cleffa.originals.build');
-
-      const pichuConfig = getNetworkConfig('pichu');
-      expect(pichuConfig.name).toBe('pichu');
-      expect(pichuConfig.domain).toBe('pichu.originals.build');
-    });
-
-    it('should throw error for invalid network', () => {
-      expect(() => getNetworkConfig('invalid' as WebVHNetworkName)).toThrow(
-        'Invalid WebVH network: invalid'
-      );
-    });
-  });
-
-  describe('getNetworkDomain', () => {
-    it('should return correct domain for each network', () => {
-      expect(getNetworkDomain('magby')).toBe('magby.originals.build');
-      expect(getNetworkDomain('cleffa')).toBe('cleffa.originals.build');
-      expect(getNetworkDomain('pichu')).toBe('pichu.originals.build');
-    });
-  });
-
-  describe('getNetworkContextUrl', () => {
-    it('should return correct context URL for each network', () => {
-      expect(getNetworkContextUrl('magby')).toBe('https://magby.originals.build/context');
-      expect(getNetworkContextUrl('cleffa')).toBe('https://cleffa.originals.build/context');
-      expect(getNetworkContextUrl('pichu')).toBe('https://pichu.originals.build/context');
-    });
-  });
-
-  describe('validateVersionForNetwork', () => {
-    describe('pichu (major releases only)', () => {
-      it('should accept major releases (X.0.0)', () => {
-        expect(validateVersionForNetwork('1.0.0', 'pichu')).toBe(true);
-        expect(validateVersionForNetwork('2.0.0', 'pichu')).toBe(true);
-        expect(validateVersionForNetwork('10.0.0', 'pichu')).toBe(true);
-      });
-
-      it('should reject minor releases (X.Y.0 where Y > 0)', () => {
-        expect(validateVersionForNetwork('1.1.0', 'pichu')).toBe(false);
-        expect(validateVersionForNetwork('2.5.0', 'pichu')).toBe(false);
-      });
-
-      it('should reject patch releases (X.Y.Z where Z > 0)', () => {
-        expect(validateVersionForNetwork('1.0.1', 'pichu')).toBe(false);
-        expect(validateVersionForNetwork('1.1.1', 'pichu')).toBe(false);
-        expect(validateVersionForNetwork('2.3.4', 'pichu')).toBe(false);
-      });
-    });
-
-    describe('cleffa (minor releases)', () => {
-      it('should accept major releases (X.0.0)', () => {
-        expect(validateVersionForNetwork('1.0.0', 'cleffa')).toBe(true);
-        expect(validateVersionForNetwork('2.0.0', 'cleffa')).toBe(true);
-      });
-
-      it('should accept minor releases (X.Y.0)', () => {
-        expect(validateVersionForNetwork('1.1.0', 'cleffa')).toBe(true);
-        expect(validateVersionForNetwork('2.5.0', 'cleffa')).toBe(true);
-        expect(validateVersionForNetwork('10.20.0', 'cleffa')).toBe(true);
-      });
-
-      it('should reject patch releases (X.Y.Z where Z > 0)', () => {
-        expect(validateVersionForNetwork('1.0.1', 'cleffa')).toBe(false);
-        expect(validateVersionForNetwork('1.1.1', 'cleffa')).toBe(false);
-        expect(validateVersionForNetwork('2.3.4', 'cleffa')).toBe(false);
-      });
-    });
-
-    describe('magby (all versions)', () => {
-      it('should accept major releases', () => {
-        expect(validateVersionForNetwork('1.0.0', 'magby')).toBe(true);
-        expect(validateVersionForNetwork('2.0.0', 'magby')).toBe(true);
-      });
-
-      it('should accept minor releases', () => {
-        expect(validateVersionForNetwork('1.1.0', 'magby')).toBe(true);
-        expect(validateVersionForNetwork('2.5.0', 'magby')).toBe(true);
-      });
-
-      it('should accept patch releases', () => {
-        expect(validateVersionForNetwork('1.0.1', 'magby')).toBe(true);
-        expect(validateVersionForNetwork('1.1.1', 'magby')).toBe(true);
-        expect(validateVersionForNetwork('2.3.4', 'magby')).toBe(true);
-      });
-    });
-
-    it('should handle pre-release versions', () => {
-      // Pre-release should still follow the same rules for the base version
-      expect(validateVersionForNetwork('1.0.0-beta.1', 'pichu')).toBe(true);
-      expect(validateVersionForNetwork('1.1.0-alpha', 'pichu')).toBe(false);
-      expect(validateVersionForNetwork('1.1.0-beta.1', 'cleffa')).toBe(true);
-      expect(validateVersionForNetwork('1.1.1-rc.1', 'cleffa')).toBe(false);
-    });
-
-    it('should throw error for invalid version format', () => {
-      expect(() => validateVersionForNetwork('invalid', 'pichu')).toThrow('Invalid version format');
-      expect(() => validateVersionForNetwork('1.0', 'pichu')).toThrow('Invalid version format');
-      expect(() => validateVersionForNetwork('v1.0.0', 'pichu')).toThrow('Invalid version format');
-    });
-  });
-
-  describe('getRecommendedNetworkForVersion', () => {
-    it('should recommend pichu for major releases', () => {
-      expect(getRecommendedNetworkForVersion('1.0.0')).toBe('pichu');
-      expect(getRecommendedNetworkForVersion('2.0.0')).toBe('pichu');
-      expect(getRecommendedNetworkForVersion('10.0.0')).toBe('pichu');
-    });
-
-    it('should recommend cleffa for minor releases', () => {
-      expect(getRecommendedNetworkForVersion('1.1.0')).toBe('cleffa');
-      expect(getRecommendedNetworkForVersion('2.5.0')).toBe('cleffa');
-      expect(getRecommendedNetworkForVersion('10.20.0')).toBe('cleffa');
-    });
-
-    it('should recommend magby for patch releases', () => {
-      expect(getRecommendedNetworkForVersion('1.0.1')).toBe('magby');
-      expect(getRecommendedNetworkForVersion('1.1.1')).toBe('magby');
-      expect(getRecommendedNetworkForVersion('2.3.4')).toBe('magby');
-    });
-
-    it('should handle pre-release versions correctly', () => {
-      expect(getRecommendedNetworkForVersion('1.0.0-beta')).toBe('pichu');
-      expect(getRecommendedNetworkForVersion('1.1.0-alpha')).toBe('cleffa');
-      expect(getRecommendedNetworkForVersion('1.1.1-rc.1')).toBe('magby');
-    });
-  });
-
-  describe('Bitcoin Network Mapping', () => {
-    describe('WEBVH_NETWORKS Bitcoin mappings', () => {
-      it('should map magby to regtest', () => {
-        expect(WEBVH_NETWORKS.magby.bitcoinNetwork).toBe('regtest');
-      });
-
-      it('should map cleffa to signet', () => {
-        expect(WEBVH_NETWORKS.cleffa.bitcoinNetwork).toBe('signet');
-      });
-
-      it('should map pichu to mainnet', () => {
-        expect(WEBVH_NETWORKS.pichu.bitcoinNetwork).toBe('mainnet');
-      });
-    });
-
-    describe('getBitcoinNetworkForWebVH', () => {
-      it('should return regtest for magby', () => {
-        expect(getBitcoinNetworkForWebVH('magby')).toBe('regtest');
-      });
-
-      it('should return signet for cleffa', () => {
-        expect(getBitcoinNetworkForWebVH('cleffa')).toBe('signet');
-      });
-
-      it('should return mainnet for pichu', () => {
-        expect(getBitcoinNetworkForWebVH('pichu')).toBe('mainnet');
-      });
-    });
-
-    describe('getWebVHNetworkForBitcoin', () => {
-      it('should return magby for regtest', () => {
-        expect(getWebVHNetworkForBitcoin('regtest')).toBe('magby');
-      });
-
-      it('should return cleffa for signet', () => {
-        expect(getWebVHNetworkForBitcoin('signet')).toBe('cleffa');
-      });
-
-      it('should return pichu for mainnet', () => {
-        expect(getWebVHNetworkForBitcoin('mainnet')).toBe('pichu');
-      });
-    });
-
-    describe('Network mapping consistency', () => {
-      it('should have bidirectional mapping for all WebVH networks', () => {
-        // magby ↔ regtest
-        const magbyBitcoin = getBitcoinNetworkForWebVH('magby');
-        expect(getWebVHNetworkForBitcoin(magbyBitcoin)).toBe('magby');
-
-        // cleffa ↔ signet
-        const cleffaBitcoin = getBitcoinNetworkForWebVH('cleffa');
-        expect(getWebVHNetworkForBitcoin(cleffaBitcoin)).toBe('cleffa');
-
-        // pichu ↔ mainnet
-        const pichuBitcoin = getBitcoinNetworkForWebVH('pichu');
-        expect(getWebVHNetworkForBitcoin(pichuBitcoin)).toBe('pichu');
-      });
-
-      it('should maintain environment consistency across networks', () => {
-        // Development: magby → regtest
-        expect(getBitcoinNetworkForWebVH('magby')).toBe('regtest');
-
-        // Staging: cleffa → signet
-        expect(getBitcoinNetworkForWebVH('cleffa')).toBe('signet');
-
-        // Production: pichu → mainnet
-        expect(getBitcoinNetworkForWebVH('pichu')).toBe('mainnet');
-      });
-    });
-  });
-});