1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
import {expect} from '@esm-bundle/chai';import * as dag from '../dag/mod';import {  addGenesis,  addIndexChange,  addLocal,  addSnapshot,  Chain,} from './test-helpers';import {Commit, fromHash as commitFromHash} from './commit';import type {IndexRecord, Meta} from './commit';import {Transformer} from './transformer';import {Hash, makeNewTempHashFunction} from '../hash';import {BTreeRead, BTreeWrite, Entry} from '../btree/mod';import type {DataNode} from '../btree/node';import type {ReadonlyJSONValue} from '../json';import {assert} from '../asserts';
test('transformBTreeInternalEntry - noop', async () => {  const dagStore = new dag.TestStore();
  await dagStore.withWrite(async dagWrite => {    const transformer = new Transformer(dagWrite);
    const dataNode: DataNode = [0, [['k', 42]]];    const chunk = dagWrite.createChunk(dataNode, []);    await dagWrite.putChunk(chunk);    const entry: Entry<Hash> = ['key', chunk.hash];
    expect(await transformer.transformBTreeInternalEntry(entry)).to.equal(      entry,    );
    expect(transformer.mappings).to.be.empty;  });});
test('transformBTreeNode - noop', async () => {  const dagStore = new dag.TestStore();
  await dagStore.withWrite(async dagWrite => {    const transformer = new Transformer(dagWrite);
    const map = new BTreeWrite(dagWrite);    await map.put('key', 'value');    const valueHash = await map.flush();
    expect(await transformer.transformBTreeNode(valueHash)).to.equal(valueHash);    expect(transformer.mappings).to.be.empty;  });});
test('transformCommit - noop', async () => {  const dagStore = new dag.TestStore();
  const testChain = async (chain: Commit<Meta>[]) => {    await dagStore.withWrite(async write => {      const transformer = new Transformer(write);
      for (const commit of chain) {        const h = commit.chunk.hash;        expect(await transformer.transformCommit(h)).to.equal(h);        expect(transformer.mappings).to.be.empty;      }    });  };
  const chain: Chain = [];  await addGenesis(chain, dagStore);  await addLocal(chain, dagStore);  await addIndexChange(chain, dagStore);  await addLocal(chain, dagStore);  await testChain(chain);
  await addSnapshot(chain, dagStore, [['k', 42]]);  await addLocal(chain, dagStore);  await testChain(chain.slice(-2));});
test('transformIndexRecord - noop', async () => {  const dagStore = new dag.TestStore();
  await dagStore.withWrite(async write => {    const transformer = new Transformer(write);
    const map = new BTreeWrite(write);    await map.put('key', 'value');    const valueHash = await map.flush();
    const index: IndexRecord = {      definition: {        jsonPointer: '',        keyPrefix: '',        name: 'index',      },      valueHash,    };
    expect(await transformer.transformIndexRecord(index)).to.equal(index);    expect(transformer.mappings).to.be.empty;  });});
test('transforms data entry', async () => {  const dagStore = new dag.TestStore(    undefined,    makeNewTempHashFunction(),    () => undefined,  );
  class TestTransformer extends Transformer {    override async transformBTreeDataEntry(      entry: Entry<ReadonlyJSONValue>,    ): Promise<Entry<ReadonlyJSONValue>> {      if (entry[0] === 'k') {        return ['k', entry[0] + ' - Changed!'];      }      return entry;    }  }
  const chain: Chain = [];  await addGenesis(chain, dagStore);  await addSnapshot(chain, dagStore, [['k', 42]]);  await addLocal(chain, dagStore);
  await dagStore.withWrite(async write => {    const transformer = new TestTransformer(write);
    const h = chain[2].chunk.hash;    const h2 = await transformer.transformCommit(h);
    await write.setHead('test', h2);    await write.commit();
    expect(Object.fromEntries(transformer.mappings)).to.deep.equal({      't/000000000000000000000000000002': 't/000000000000000000000000000007',      't/000000000000000000000000000003': 't/000000000000000000000000000008',      't/000000000000000000000000000004': 't/000000000000000000000000000006',      ['t/000000000000000000000000000005']: 't/000000000000000000000000000009',    });  });
  await dagStore.withRead(async read => {    const headHash = await read.getHead('test');    assert(headHash);    const commit = await commitFromHash(headHash, read);    const map = new BTreeRead(read, commit.valueHash);    expect(await map.get('k')).to.equal('k - Changed!');  });});