initial refactor of feaure flag detection statements in serverRequest()

js/modules/loki_app_dot_net_api.js

@@ -388,12 +388,8 @@ class LokiAppDotNetServerAPI {
     if (params) {
       url.search = new URLSearchParams(params);
     }
-    let result;
+    const fetchOptions = {};
-    let ephemeralKey;
-    let symKey;
-    let iv;
     try {
-      const fetchOptions = {};
       const headers = {};
       if (forceFreshToken) {
         await this.getOrRefreshServerToken(true);
@@ -411,86 +407,85 @@ class LokiAppDotNetServerAPI {
         fetchOptions.body = rawBody;
       }
       fetchOptions.headers = new Headers(headers);
+    } catch (e) {
+      log.info('serverRequest set up error:', JSON.stringify(e));
+      return {
+        err: e,
+      };
+    }
 
-      if (
+    let result;
-        window.lokiFeatureFlags.useSnodeProxy &&
+    let response = null;
-        (this.baseServerUrl === 'https://file-dev.lokinet.org' ||
+    let TxtResponse = '';
-          this.baseServerUrl === 'https://file.lokinet.org')
+    if (
-      ) {
+      window.lokiFeatureFlags.useSnodeProxy &&
+      (this.baseServerUrl === 'https://file-dev.lokinet.org' ||
+        this.baseServerUrl === 'https://file.lokinet.org')
+    ) {
+      try {
         // make temporary key for this request/response
-        ephemeralKey = libsignal.Curve.generateKeyPair();
+        const ephemeralKey = libsignal.Curve.generateKeyPair();
         // mix server pub key with our priv key
-        symKey = libsignal.Curve.calculateAgreement(
+        const symKey = libsignal.Curve.calculateAgreement(
           this.pubKey, // server's pubkey
           ephemeralKey.privKey // our privkey
         );
+
         // some randomness
-        iv = libsignal.crypto.getRandomBytes(IV_LENGTH);
+        const iv = libsignal.crypto.getRandomBytes(IV_LENGTH);
 
-        log.info('Sending a proxy request to', this.baseServerUrl);
         result = await this.constructor._sendToProxy(
-          { ...fetchOptions, headers },
+          fetchOptions,
           endpoint,
           method,
           { ephemeralKey, symKey, iv }
         );
-        // log.info('sent to proxy')
-      } else {
-        result = await nodeFetch(url, fetchOptions || undefined);
-      }
-    } catch (e) {
-      log.info(
-        'serverRequest nodeFetch/_sendToProxy error:',
-        JSON.stringify(e)
-      );
-      return {
-        err: e,
-      };
-    }
-    let response = null;
-    let TxtResponse = '';
-    try {
-      TxtResponse = await result.text();
-      response = JSON.parse(TxtResponse);
-    } catch (e) {
-      log.warn(`serverRequest json parse ${e} ${TxtResponse}`);
-      return {
-        err: e,
-        statusCode: result.status,
-      };
-    }
 
-    if (
+        TxtResponse = await result.text();
-      window.lokiFeatureFlags.useSnodeProxy &&
+        response = JSON.parse(TxtResponse);
-      (this.baseServerUrl === 'https://file-dev.lokinet.org' ||
+
-        this.baseServerUrl === 'https://file.lokinet.org')
+        if (response.meta && response.meta.code === 200) {
-    ) {
+          try {
-      // log.info('Got proxy response', response, 'for', method || 'GET', endpoint);
+            const cipherBuffer = dcodeIO.ByteBuffer.wrap(
-      if (response.meta && response.meta.code === 200) {
+              response.data,
-        try {
+              'base64'
-          const cipherBuffer = dcodeIO.ByteBuffer.wrap(
+            ).toArrayBuffer();
-            response.data,
+            const decryped = await libsignal.crypto.decrypt(
-            'base64'
+              symKey,
-          ).toArrayBuffer();
+              cipherBuffer,
-          const decryped = await libsignal.crypto.decrypt(
+              iv
-            symKey,
+            );
-            cipherBuffer,
+            const textDecoder = new TextDecoder();
-            iv
+            const json = textDecoder.decode(decryped);
-          );
+            // replace response
-          const textDecoder = new TextDecoder();
+            response = JSON.parse(json);
-          const json = textDecoder.decode(decryped);
+          } catch (e) {
-          response = JSON.parse(json);
+            // useless with the ephemeralKey and iv
-        } catch (e) {
+            log.warn(`serverRequest useSnodeProxy parse ${e} ${TxtResponse}`);
-          // useless with the ephemeralKey and iv
+            return {
-          log.warn(`serverRequest useSnodeProxy parse ${e} ${TxtResponse}`);
+              err: e,
-          return {
+              statusCode: result.status,
-            err: e,
+            };
-            statusCode: result.status,
+          }
-          };
+        } else {
+          log.warn('file server secure_rpc gave an non-200 response');
         }
-        // log.info('decrypted response', response);
+      } catch (e) {
-      } else {
+        log.info('serverRequest _sendToProxy error:', e);
-        log.warn('file server secure_rpc gave an non-200 response');
+        return {
+          err: e,
+        };
+      }
+    } else {
+      try {
+        result = await nodeFetch(url, fetchOptions || undefined);
+        TxtResponse = await result.text();
+        response = JSON.parse(TxtResponse);
+      } catch (e) {
+        log.info('serverRequest nodeFetch error:', JSON.stringify(e));
+        return {
+          err: e,
+        };
       }
     }