simplify websocket opening and response types from BE

client/lib/source/mock-source.ts

@@ -1,13 +1,11 @@
 import { Observable } from 'rxjs'
-import { map } from 'rxjs/operators'
 import { Update } from '../types'
 import { Source } from './source'
-import { RPCResponse } from './ws-source'
 
 export class MockSource<T> implements Source<T> {
   constructor(private readonly seed: Observable<Update<T>>) {}
 
-  watch$(): Observable<RPCResponse<Update<T>>> {
-    return this.seed.pipe(map(result => ({ result, jsonrpc: '2.0' })))
+  watch$(): Observable<Update<T>> {
+    return this.seed
   }
 }

client/lib/source/poll-source.ts

@@ -3,7 +3,6 @@ import { concatMap, map, take } from 'rxjs/operators'
 import { Store } from '../store'
 import { Http, Update } from '../types'
 import { Source } from './source'
-import { RPCResponse } from './ws-source'
 
 export type PollConfig = {
   cooldown: number
@@ -15,13 +14,12 @@ export class PollSource<T> implements Source<T> {
     private readonly http: Http<T>,
   ) {}
 
-  watch$({ sequence$ }: Store<T>): Observable<RPCResponse<Update<T>>> {
+  watch$({ sequence$ }: Store<T>): Observable<Update<T>> {
     return sequence$.pipe(
       concatMap(seq => this.http.getRevisions(seq)),
       take(1),
-      // Revision[] converted it into Observable<Revision>, Dump<T> into Observable<Dump<T>>
+      // convert Revision[] it into Observable<Revision>. Convert Dump<T> into Observable<Dump<T>>
       concatMap(res => (Array.isArray(res) ? from(res) : of(res))),
-      map(result => ({ result, jsonrpc: '2.0' as const })),
       repeatWhen(() => timer(this.pollConfig.cooldown)),
     )
   }

client/lib/source/source.ts

@@ -1,8 +1,7 @@
 import { Observable } from 'rxjs'
 import { Store } from '../store'
 import { Update } from '../types'
-import { RPCResponse } from './ws-source'
 
 export interface Source<T> {
-  watch$(store?: Store<T>): Observable<RPCResponse<Update<T>>>
+  watch$(store?: Store<T>): Observable<Update<T>>
 }

client/lib/source/ws-source.ts

@@ -1,54 +1,12 @@
 import { Observable, timeout } from 'rxjs'
-import { webSocket, WebSocketSubject } from 'rxjs/webSocket'
+import { webSocket } from 'rxjs/webSocket'
 import { Update } from '../types'
 import { Source } from './source'
 
 export class WebsocketSource<T> implements Source<T> {
-  constructor(
-    private readonly url: string,
-    // TODO: Remove fallback after client app is updated
-    private readonly document: Document = document,
-  ) {}
+  constructor(private readonly url: string) {}
 
-  watch$(): Observable<RPCResponse<Update<T>>> {
-    const stream$: WebSocketSubject<RPCResponse<Update<T>>> = webSocket({
-      url: this.url,
-      openObserver: {
-        next: () => stream$.next(this.document.cookie as any),
-      },
-    })
-
-    return stream$.pipe(timeout({ first: 60000 }))
-  }
-}
-
-interface RPCBase {
-  jsonrpc: '2.0'
-}
-
-export interface RPCSuccess<T> extends RPCBase {
-  result: T
-}
-
-export interface RPCError extends RPCBase {
-  error: {
-    code: number // 34 means unauthenticated
-    message: string
-    data: {
-      details: string
-    }
-  }
-}
-export type RPCResponse<T> = RPCSuccess<T> | RPCError
-
-class RpcError {
-  code: number
-  message: string
-  details: string
-
-  constructor(e: RPCError['error']) {
-    this.code = e.code
-    this.message = e.message
-    this.details = e.data.details
+  watch$(): Observable<Update<T>> {
+    return webSocket<Update<T>>(this.url).pipe(timeout({ first: 60000 }))
   }
 }