use the same context for loadAllChanges whilst loading an object from the store

Author: sbazerque

src/data/model/immutable/HashedObject.ts

@@ -437,6 +437,9 @@ abstract class HashedObject {
 
     static collectDirectSubobjects(path: string, value: any, subobjects: Map<string, HashedObject>) {
 
+        //console.log('called collectDirectSubobjects() w/path', path, 'subobjects: ', subobjects.size);
+        //console.log(new Error().stack);
+
         let typ = typeof(value);
 
         // We're only concerned with 'object' typed stuff, since scalars, strings, etc. cannot yield
@@ -1062,12 +1065,12 @@ abstract class HashedObject {
         return this._boundToStore;
     }
 
-    async loadAllChanges(loadBatchSize=128) {
+    async loadAllChanges(loadBatchSize=128, context = new Context()) {
 
         const subobjs = new Set(this.getDirectSubObjects().values());
 
         for (const subobj of subobjs.values()) {
-            await subobj.loadAllChanges(loadBatchSize);
+            await subobj.loadAllChanges(loadBatchSize, context);
         }
     }
 }

src/data/model/mutable/MutableObject.ts

@@ -220,9 +220,9 @@ abstract class  MutableObject extends HashedObject {
 
     }
 
-    async loadAllChanges(batchSize=128) {
+    async loadAllChanges(batchSize=128, context = new Context()) {
 
-        await super.loadAllChanges(batchSize);
+        await super.loadAllChanges(batchSize, context);
 
         let results = await this.getStore()
                                 .loadByReference(
@@ -231,7 +231,8 @@ abstract class  MutableObject extends HashedObject {
                                     {
                                         order: 'asc',
                                         limit: batchSize
-                                    });
+                                    },
+                                    context);
 
         while (results.objects.length > 0) {
 
@@ -249,7 +250,8 @@ abstract class  MutableObject extends HashedObject {
                                         order: 'asc',
                                         limit: batchSize,
                                         start: results.end
-                                    });
+                                    },
+                                    context);
         }
     }
 

src/storage/store/Store.ts

@@ -504,7 +504,7 @@ class Store {
             }
 
             //console.log('+++ loading changes for ' + hash + ' ', new Error().stack);
-            await object.loadAllChanges();
+            await object.loadAllChanges(undefined, context);
 
             /*for (const subobj of context.objects.values()) {
                 if (watchForChanges) {
@@ -588,26 +588,26 @@ class Store {
         return obj;
     }
 
-    async loadByClass(className: string, params?: LoadParams) : Promise<LoadResults> {
+    async loadByClass(className: string, params?: LoadParams, context = new Context()) : Promise<LoadResults> {
 
         let searchResults = await this.backend.searchByClass(className, params);
 
-        return this.loadSearchResults(searchResults);
+        return this.loadSearchResults(searchResults, context);
 
     }
 
-    async loadByReference(referringPath: string, referencedHash: Hash, params?: LoadParams) : Promise<LoadResults> {
+    async loadByReference(referringPath: string, referencedHash: Hash, params?: LoadParams, context = new Context()) : Promise<LoadResults> {
 
         let searchResults = await this.backend.searchByReference(referringPath, referencedHash, params);
 
-        return this.loadSearchResults(searchResults);
+        return this.loadSearchResults(searchResults, context);
     }
 
-    async loadByReferencingClass(referringClassName: string, referringPath: string, referencedHash: Hash, params?: LoadParams) : Promise<LoadResults> {
+    async loadByReferencingClass(referringClassName: string, referringPath: string, referencedHash: Hash, params?: LoadParams, context = new Context()) : Promise<LoadResults> {
 
         let searchResults = await this.backend.searchByReferencingClass(referringClassName, referringPath, referencedHash, params);
 
-        return this.loadSearchResults(searchResults);
+        return this.loadSearchResults(searchResults, context);
     }
 
     async loadOpHeader(opHash: Hash): Promise<OpHeader | undefined> {
@@ -659,9 +659,7 @@ class Store {
         return literal;
     }*/
 
-    private async loadSearchResults(searchResults: BackendSearchResults) : Promise<{objects: Array<HashedObject>, start?: string, end?: string}> {
-
-        let context = new Context();
+    private async loadSearchResults(searchResults: BackendSearchResults, context = new Context()) : Promise<{objects: Array<HashedObject>, start?: string, end?: string}> {
 
         let objects = [] as Array<HashedObject>;
 

test/data/collections/causal/reference.test.ts

@@ -85,8 +85,6 @@ describeProxy('[CRF] Causal references', () => {
 
         await mutWritersClone.save();
 
-        console.log('FINAL LOADING!')
-
         let refClone = await store.load(ref.hash()) as CausalReference<string>;
 
         expect (refClone.getValue()).toEqual('2');

test/data/collections/causal/set.test.ts

@@ -118,7 +118,7 @@ describeProxy('[CST] Causal sets', () => {
 
         done();
 
-    });
+    }, 10000);
 
     test('[CST03] Causal set redo', async (done) => {
         let store = new Store(new IdbBackend('CST02 - ' + new RNGImpl().randomHexString(128)));