Add formatted source code

1 files changed, 151 insertions, 137 deletions

diff --git a/app/lib/ipc-facade.js b/app/lib/ipc-facade.js
index 0a64a5cc68..0aa1d48d3f 100644
--- a/app/lib/ipc-facade.js
+++ b/app/lib/ipc-facade.js
@@ -1,7 +1,16 @@
 // @flow
 
 import JsonRpcWs, { InvalidReply } from './jsonrpc-ws-ipc';
-import { object, maybe, string, number, boolean, enumeration, arrayOf, oneOf } from 'validated/schema';
+import {
+  object,
+  maybe,
+  string,
+  number,
+  boolean,
+  enumeration,
+  arrayOf,
+  oneOf,
+} from 'validated/schema';
 import { validate } from 'validated/object';
 
 import type { Node as SchemaNode } from 'validated/schema';
@@ -45,12 +54,16 @@ type TunnelOptions<TOpenVpnParameters> = {
 };
 
 type RelaySettingsNormal<TTunnelOptions> = {
-  location: 'any' | {
-    only: RelayLocation,
-  },
-  tunnel: 'any' | {
-    only: TTunnelOptions
-  },
+  location:
+    | 'any'
+    | {
+        only: RelayLocation,
+      },
+  tunnel:
+    | 'any'
+    | {
+        only: TTunnelOptions,
+      },
 };
 
 // types describing the structure of RelaySettings
@@ -59,46 +72,60 @@ export type RelaySettingsCustom = {
   tunnel: {
     openvpn: {
       port: number,
-      protocol: RelayProtocol
-    }
-  }
+      protocol: RelayProtocol,
+    },
+  },
 };
-export type RelaySettings = {|
-  normal: RelaySettingsNormal<TunnelOptions<OpenVpnParameters>>
-|} | {|
-  custom_tunnel_endpoint: RelaySettingsCustom
-|};
+export type RelaySettings =
+  | {|
+      normal: RelaySettingsNormal<TunnelOptions<OpenVpnParameters>>,
+    |}
+  | {|
+      custom_tunnel_endpoint: RelaySettingsCustom,
+    |};
 
 // types describing the partial update of RelaySettings
-export type RelaySettingsNormalUpdate = $Shape< RelaySettingsNormal< TunnelOptions<$Shape<OpenVpnParameters> > > >;
-export type RelaySettingsUpdate = {|
-  normal: RelaySettingsNormalUpdate
-|} | {|
-  custom_tunnel_endpoint: RelaySettingsCustom
-|};
+export type RelaySettingsNormalUpdate = $Shape<
+  RelaySettingsNormal<TunnelOptions<$Shape<OpenVpnParameters>>>,
+>;
+export type RelaySettingsUpdate =
+  | {|
+      normal: RelaySettingsNormalUpdate,
+    |}
+  | {|
+      custom_tunnel_endpoint: RelaySettingsCustom,
+    |};
 
-const constraint = <T>(constraintValue: SchemaNode<T>) => oneOf(string, object({
-  only: constraintValue,
-}));
+const constraint = <T>(constraintValue: SchemaNode<T>) =>
+  oneOf(
+    string,
+    object({
+      only: constraintValue,
+    }),
+  );
 
 const RelaySettingsSchema = oneOf(
   object({
     normal: object({
-      location: constraint(oneOf(
-        object({
-          city: arrayOf(string),
-        }),
+      location: constraint(
+        oneOf(
+          object({
+            city: arrayOf(string),
+          }),
+          object({
+            country: string,
+          }),
+        ),
+      ),
+      tunnel: constraint(
         object({
-          country: string
+          openvpn: object({
+            port: constraint(number),
+            protocol: constraint(enumeration('udp', 'tcp')),
+          }),
         }),
-      )),
-      tunnel: constraint(object({
-        openvpn: object({
-          port: constraint(number),
-          protocol: constraint(enumeration('udp', 'tcp')),
-        }),
-      })),
-    })
+      ),
+    }),
   }),
   object({
     custom_tunnel_endpoint: object({
@@ -107,10 +134,10 @@ const RelaySettingsSchema = oneOf(
         openvpn: object({
           port: number,
           protocol: enumeration('udp', 'tcp'),
-        })
-      })
-    })
-  })
+        }),
+      }),
+    }),
+  }),
 );
 
 export type RelayList = {
@@ -132,44 +159,46 @@ export type RelayListCity = {
 };
 
 const RelayListSchema = object({
-  countries: arrayOf(object({
-    name: string,
-    code: string,
-    cities: arrayOf(object({
+  countries: arrayOf(
+    object({
       name: string,
       code: string,
-      latitude: number,
-      longitude: number,
-      has_active_relays: boolean,
-    })),
-  })),
+      cities: arrayOf(
+        object({
+          name: string,
+          code: string,
+          latitude: number,
+          longitude: number,
+          has_active_relays: boolean,
+        }),
+      ),
+    }),
+  ),
 });
 
-
 export interface IpcFacade {
-  setConnectionString(string): void,
-  getAccountData(AccountToken): Promise<AccountData>,
-  getRelayLocations(): Promise<RelayList>,
-  getAccount(): Promise<?AccountToken>,
-  setAccount(accountToken: ?AccountToken): Promise<void>,
-  updateRelaySettings(RelaySettingsUpdate): Promise<void>,
-  getRelaySettings(): Promise<RelaySettings>,
-  setAllowLan(boolean): Promise<void>,
-  getAllowLan(): Promise<boolean>,
-  connect(): Promise<void>,
-  disconnect(): Promise<void>,
-  shutdown(): Promise<void>,
-  getLocation(): Promise<Location>,
-  getState(): Promise<BackendState>,
-  registerStateListener((BackendState) => void): void,
-  setCloseConnectionHandler(() => void): void,
-  authenticate(sharedSecret: string): Promise<void>,
-  getAccountHistory(): Promise<Array<AccountToken>>,
-  removeAccountFromHistory(accountToken: AccountToken): Promise<void>,
+  setConnectionString(string): void;
+  getAccountData(AccountToken): Promise<AccountData>;
+  getRelayLocations(): Promise<RelayList>;
+  getAccount(): Promise<?AccountToken>;
+  setAccount(accountToken: ?AccountToken): Promise<void>;
+  updateRelaySettings(RelaySettingsUpdate): Promise<void>;
+  getRelaySettings(): Promise<RelaySettings>;
+  setAllowLan(boolean): Promise<void>;
+  getAllowLan(): Promise<boolean>;
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  shutdown(): Promise<void>;
+  getLocation(): Promise<Location>;
+  getState(): Promise<BackendState>;
+  registerStateListener((BackendState) => void): void;
+  setCloseConnectionHandler(() => void): void;
+  authenticate(sharedSecret: string): Promise<void>;
+  getAccountHistory(): Promise<Array<AccountToken>>;
+  removeAccountFromHistory(accountToken: AccountToken): Promise<void>;
 }
 
 export class RealIpc implements IpcFacade {
-
   _ipc: JsonRpcWs;
 
   constructor(connectionString: string) {
@@ -184,14 +213,13 @@ export class RealIpc implements IpcFacade {
     // send the IPC with 30s timeout since the backend will wait
     // for a HTTP request before replying
 
-    return this._ipc.send('get_account_data', accountToken, 30000)
-      .then(raw => {
-        if (typeof raw === 'object' && raw && raw.expiry) {
-          return raw;
-        } else {
-          throw new InvalidReply(raw, 'Expected an object with expiry');
-        }
-      });
+    return this._ipc.send('get_account_data', accountToken, 30000).then((raw) => {
+      if (typeof raw === 'object' && raw && raw.expiry) {
+        return raw;
+      } else {
+        throw new InvalidReply(raw, 'Expected an object with expiry');
+      }
+    });
   }
 
   async getRelayLocations(): Promise<RelayList> {
@@ -205,19 +233,17 @@ export class RealIpc implements IpcFacade {
   }
 
   getAccount(): Promise<?AccountToken> {
-    return this._ipc.send('get_account')
-      .then( raw => {
-        if (raw === undefined || raw === null || typeof raw === 'string') {
-          return raw;
-        } else {
-          throw new InvalidReply(raw);
-        }
-      });
+    return this._ipc.send('get_account').then((raw) => {
+      if (raw === undefined || raw === null || typeof raw === 'string') {
+        return raw;
+      } else {
+        throw new InvalidReply(raw);
+      }
+    });
   }
 
   setAccount(accountToken: ?AccountToken): Promise<void> {
-    return this._ipc.send('set_account', accountToken)
-      .then(this._ignoreResponse);
+    return this._ipc.send('set_account', accountToken).then(this._ignoreResponse);
   }
 
   _ignoreResponse(_response: mixed): void {
@@ -225,30 +251,27 @@ export class RealIpc implements IpcFacade {
   }
 
   updateRelaySettings(relaySettings: RelaySettingsUpdate): Promise<void> {
-    return this._ipc.send('update_relay_settings', [relaySettings])
-      .then(this._ignoreResponse);
+    return this._ipc.send('update_relay_settings', [relaySettings]).then(this._ignoreResponse);
   }
 
   getRelaySettings(): Promise<RelaySettings> {
-    return this._ipc.send('get_relay_settings')
-      .then( raw => {
-        try {
-          const validated: any = validate(RelaySettingsSchema, raw);
-          return (validated: RelaySettings);
-        } catch (e) {
-          throw new InvalidReply(raw, e);
-        }
-      });
+    return this._ipc.send('get_relay_settings').then((raw) => {
+      try {
+        const validated: any = validate(RelaySettingsSchema, raw);
+        return (validated: RelaySettings);
+      } catch (e) {
+        throw new InvalidReply(raw, e);
+      }
+    });
   }
 
   setAllowLan(allowLan: boolean): Promise<void> {
-    return this._ipc.send('set_allow_lan', [allowLan])
-      .then(this._ignoreResponse);
+    return this._ipc.send('set_allow_lan', [allowLan]).then(this._ignoreResponse);
   }
 
   async getAllowLan(): Promise<boolean> {
     const raw = await this._ipc.send('get_allow_lan');
-    if(typeof(raw) === 'boolean') {
+    if (typeof raw === 'boolean') {
       return raw;
     } else {
       throw new InvalidReply(raw, 'Expected a boolean');
@@ -256,45 +279,39 @@ export class RealIpc implements IpcFacade {
   }
 
   connect(): Promise<void> {
-    return this._ipc.send('connect')
-      .then(this._ignoreResponse);
+    return this._ipc.send('connect').then(this._ignoreResponse);
   }
 
   disconnect(): Promise<void> {
-    return this._ipc.send('disconnect')
-      .then(this._ignoreResponse);
+    return this._ipc.send('disconnect').then(this._ignoreResponse);
   }
 
   shutdown(): Promise<void> {
-    return this._ipc.send('shutdown')
-      .then(this._ignoreResponse);
+    return this._ipc.send('shutdown').then(this._ignoreResponse);
   }
 
   getLocation(): Promise<Location> {
     // send the IPC with 30s timeout since the backend will wait
     // for a HTTP request before replying
 
-    return this._ipc.send('get_current_location', [], 30000)
-      .then(raw => {
-        try {
-          const validated: any = validate(LocationSchema, raw);
-          return (validated: Location);
-        } catch (e) {
-          throw new InvalidReply(raw, e);
-        }
-      });
+    return this._ipc.send('get_current_location', [], 30000).then((raw) => {
+      try {
+        const validated: any = validate(LocationSchema, raw);
+        return (validated: Location);
+      } catch (e) {
+        throw new InvalidReply(raw, e);
+      }
+    });
   }
 
   getState(): Promise<BackendState> {
-    return this._ipc.send('get_state')
-      .then(raw => {
-        return this._parseBackendState(raw);
-      });
+    return this._ipc.send('get_state').then((raw) => {
+      return this._parseBackendState(raw);
+    });
   }
 
   _parseBackendState(raw: mixed): BackendState {
     if (raw && raw.state && raw.target_state) {
-
       const uncheckedRaw: any = raw;
 
       const states: Array<SecurityState> = ['secured', 'unsecured'];
@@ -313,7 +330,7 @@ export class RealIpc implements IpcFacade {
 
   registerStateListener(listener: (BackendState) => void) {
     this._ipc.on('new_state', (rawEvent) => {
-      const parsedEvent : BackendState = this._parseBackendState(rawEvent);
+      const parsedEvent: BackendState = this._parseBackendState(rawEvent);
 
       listener(parsedEvent);
     });
@@ -324,24 +341,21 @@ export class RealIpc implements IpcFacade {
   }
 
   authenticate(sharedSecret: string): Promise<void> {
-    return this._ipc.send('auth', sharedSecret)
-      .then(this._ignoreResponse);
+    return this._ipc.send('auth', sharedSecret).then(this._ignoreResponse);
   }
 
   getAccountHistory(): Promise<Array<AccountToken>> {
-    return this._ipc.send('get_account_history')
-      .then(raw => {
-        if(Array.isArray(raw) && raw.every(i => typeof i === 'string')) {
-          const checked: any = raw;
-          return (checked: Array<AccountToken>);
-        } else {
-          throw new InvalidReply(raw, 'Expected an array of strings');
-        }
-      });
+    return this._ipc.send('get_account_history').then((raw) => {
+      if (Array.isArray(raw) && raw.every((i) => typeof i === 'string')) {
+        const checked: any = raw;
+        return (checked: Array<AccountToken>);
+      } else {
+        throw new InvalidReply(raw, 'Expected an array of strings');
+      }
+    });
   }
 
   removeAccountFromHistory(accountToken: AccountToken): Promise<void> {
-    return this._ipc.send('remove_account_from_history', accountToken)
-      .then(this._ignoreResponse);
+    return this._ipc.send('remove_account_from_history', accountToken).then(this._ignoreResponse);
   }
 }