Rudimentary checkpoint support for MutableReference

Author: micahscopes

src/data/collections/mutable/MutableReference.ts

@@ -17,8 +17,8 @@ class MutableReference<T> extends BaseCollection<T> {
     _value?: T;
 
     constructor(config?: CollectionConfig) {
-        super([RefUpdateOp.className], config);
-
+        super([RefUpdateOp.className], {supportsCheckpoints: true, ...config});
+        
         this.setRandomId();
     }
 
@@ -101,6 +101,20 @@ class MutableReference<T> extends BaseCollection<T> {
     init(): void {
 
     }
+    
+    exportMutableState() {
+        return {
+            _sequence: this._sequence,
+            _timestamp: this._timestamp,
+            _value: this._value
+        };
+    }
+    
+    importMutableState(state: any) {
+        this._sequence = state._sequence;
+        this._timestamp = state._timestamp;
+        this._value = state._value;
+    }
 
     async validate(references: Map<Hash, HashedObject>) {
 

src/data/collections/mutable/MutableSet.ts

@@ -206,6 +206,18 @@ class MutableSet<T> extends BaseCollection<T> implements Collection<T> {
     init(): void {
 
     }
+    
+    exportMutableState() {
+        return {
+            _elements: this._elements,
+            _currentAddOpRefs: this._currentAddOpRefs
+        };
+    }
+
+    importMutableState(state: any): void {
+        this._elements = new Map(Object.entries(state._elements));
+        this._currentAddOpRefs = new Map(Object.entries(state._currentAddOpRefs));
+    }
 
     async validate(references: Map<Hash, HashedObject>) {
 

test/storage/store.test.ts

@@ -7,6 +7,7 @@ import { SomethingMutable, SomeMutation } from '../data//types/SomethingMutable'
 import { describeProxy } from 'config';
 import { HistoryFragment } from 'data/history/HistoryFragment';
 import { OpHeader } from 'data/history/OpHeader';
+import { MutableReference } from 'index';
 
 //import { SQLiteBackend } from '@hyper-hyper-space/sqlite';
 
@@ -138,6 +139,12 @@ describeProxy('[STR] Storage', () => {
         store.close();
     });*/
 
+    test('[STR19] Validate save/load checkpoint cycle for MutableReference with memory store', async () => {
+        let store = new Store(new MemoryBackend('test-storage-backend'));
+        await testCheckpointSaveLoadCycle(store);
+        store.close();
+    })
+
 });
 
 async function testLoadStoreCycle(store: Store) {
@@ -223,6 +230,27 @@ async function testMutationOps(store: Store) {
     }
 }
 
+async function testCheckpointSaveLoadCycle(store: Store) {
+    let sm = new MutableReference();
+    await sm.setValue('hello');
+    await store.save(sm);
+    await sm.saveCheckpoint();
+    const lastCheckpoint = await store.loadLastCheckpoint(sm.hash());
+    expect(sm.getValue()).toEqual('hello');
+
+    await sm.setValue('world');
+    await sm.setValue('!');
+    await store.save(sm);
+    expect(sm.getValue()).toEqual('!');
+    
+    await sm.restoreCheckpoint(lastCheckpoint!);
+    expect(sm.getValue()).toEqual('hello');
+    await store.save(sm);
+
+    await sm.loadAllChanges();
+    expect(sm.getValue()).toEqual('!');
+}
+
 async function testMutationOpAutoLoad(store: Store) {
     let sm = new SomethingMutable();