1 files changed, 24 insertions, 32 deletions

diff --git a/src/client/DocServer.ts b/src/client/DocServer.ts
index fc39fa364..87a87be92 100644
--- a/src/client/DocServer.ts
+++ b/src/client/DocServer.ts
@@ -124,13 +124,12 @@ export namespace DocServer {
             // future .proto calls on the Doc won't have to go farther than the cache to get their actual value.
             const deserializeField = getSerializedField.then(async fieldJson => {
                 // deserialize
-                const field = await SerializationHelper.Deserialize(fieldJson, val => {
-                    if (val !== undefined) {
-                        _cache[id] = val;
-                    } else {
-                        delete _cache[id];
-                    }
-                });
+                const field = await SerializationHelper.Deserialize(fieldJson);
+                if (field !== undefined) {
+                    _cache[id] = field;
+                } else {
+                    delete _cache[id];
+                }
                 return field;
                 // either way, overwrite or delete any promises cached at this id (that we inserted as flags
                 // to indicate that the field was in the process of being fetched). Now everything
@@ -214,36 +213,37 @@ export namespace DocServer {
         // future .proto calls on the Doc won't have to go farther than the cache to get their actual value.
         const deserializeFields = getSerializedFields.then(async fields => {
             const fieldMap: { [id: string]: RefField } = {};
-            // const protosToLoad: any = [];
-            const proms: Promise<RefField>[] = [];
+            const proms: Promise<void>[] = [];
             for (const field of fields) {
                 if (field !== undefined) {
                     // deserialize
-                    let prom = SerializationHelper.Deserialize(field, val => {
-                        if (val !== undefined) {
-                            _cache[field.id] = field;
+                    let prom = SerializationHelper.Deserialize(field).then(deserialized => {
+                        fieldMap[field.id] = deserialized;
+
+                        //overwrite or delete any promises (that we inserted as flags
+                        // to indicate that the field was in the process of being fetched). Now everything
+                        // should be an actual value within or entirely absent from the cache.
+                        if (deserialized !== undefined) {
+                            _cache[field.id] = deserialized;
                         } else {
                             delete _cache[field.id];
                         }
-                    }).then(deserialized => fieldMap[field.id] = deserialized);
-                    proms.push(prom);
+                        return deserialized;
+                    });
+                    // 4) here, for each of the documents we've requested *ourselves* (i.e. weren't promises or found in the cache)
+                    // we set the value at the field's id to a promise that will resolve to the field. 
+                    // When we find that promises exist at keys in the cache, THIS is where they were set, just by some other caller (method).
+                    // The mapping in the .then call ensures that when other callers await these promises, they'll
+                    // get the resolved field
+                    _cache[field.id] = prom;
                     // adds to a list of promises that will be awaited asynchronously
-                    // protosToLoad.push(deserialized.proto);
+                    proms.push(prom);
                 }
             }
             await Promise.all(proms);
-            // this actually handles the loading of prototypes
-            // await Promise.all(protosToLoad);
             return fieldMap;
         });
 
-        // 4) here, for each of the documents we've requested *ourselves* (i.e. weren't promises or found in the cache)
-        // we set the value at the field's id to a promise that will resolve to the field. 
-        // When we find that promises exist at keys in the cache, THIS is where they were set, just by some other caller (method).
-        // The mapping in the .then call ensures that when other callers await these promises, they'll
-        // get the resolved field
-        requestedIds.forEach(id => _cache[id] = deserializeFields.then(fields => fields[id]));
-
         // 5) at this point, all fields have a) been returned from the server and b) been deserialized into actual Field objects whose
         // prototype documents, if any, have also been fetched and cached.
         const fields = await deserializeFields;
@@ -253,14 +253,6 @@ export namespace DocServer {
         // id to the soon-to-be-returned field mapping.
         requestedIds.forEach(id => {
             const field = fields[id];
-            // either way, overwrite or delete any promises (that we inserted as flags
-            // to indicate that the field was in the process of being fetched). Now everything
-            // should be an actual value within or entirely absent from the cache.
-            if (field !== undefined) {
-                _cache[id] = field;
-            } else {
-                delete _cache[id];
-            }
             map[id] = field;
         });