[rpc-client] rework package so it works after building.. still needs research

packages/roleypoly-rpc-client/src/error.js

@@ -0,0 +1,21 @@
+// @flow
+import type { RPCResponse } from './index'
+
+class RPCError extends Error {
+  code: ?number
+  extra: any[]
+  remoteStack: ?string
+  constructor (msg: string, code?: number, ...extra: any[]) {
+    super(msg)
+    this.code = code
+    this.extra = extra
+  }
+
+  static fromResponse (body: RPCResponse, status: number) {
+    const e = new RPCError(body.msg, status)
+    e.remoteStack = body.trace
+    return e
+  }
+}
+
+module.exports = RPCError

packages/roleypoly-rpc-client/src/index.js

@@ -0,0 +1,158 @@
+// @flow
+import superagent from 'superagent'
+import RPCError from './error'
+import retry from 'async-retry'
+
+export type RPCResponse = {
+  response?: mixed,
+  hash?: string,
+
+  // error stuff
+  error?: boolean,
+  msg: string,
+  trace?: string
+}
+
+export type RPCRequest = {
+  fn: string,
+  args: mixed[]
+}
+
+export default class RPCClient {
+  dev: boolean = false
+  baseUrl: string
+  firstKnownHash: string
+  recentHash: string
+  cookieHeader: string
+
+  headerMixins: {
+    [x:string]: string
+  } = {}
+
+  rpc: {
+    [fn: string]: (...args: any[]) => Promise<any>
+  } = {}
+
+  __rpcAvailable: Array<{
+    name: string,
+    args: number
+  }> = []
+
+  retry: boolean
+
+  constructor ({ forceDev, baseUrl = '/api/_rpc', retry = false }: { forceDev?: boolean, baseUrl?: string, retry?: boolean } = {}) {
+    this.baseUrl = (process.env.APP_URL || '') + baseUrl
+
+    if (forceDev != null) {
+      this.dev = forceDev
+    } else {
+      this.dev = process.env.NODE_ENV === 'development'
+    }
+
+    this.retry = retry
+
+    this.rpc = new Proxy({}, {
+      get: this.__rpcCall,
+      has: this.__checkCall,
+      ownKeys: this.__listCalls,
+      delete: () => {}
+    })
+
+    if (this.dev) {
+      this.updateCalls()
+    }
+  }
+
+  withCookies = (h: string) => {
+    this.cookieHeader = h
+    return this.rpc
+  }
+
+  withBotAuth = (h: string) => {
+    this.headerMixins['Authorization'] = `Bot ${h}`
+    return this.rpc
+  }
+
+  async updateCalls () {
+    // this is for development only. doing in prod is probably dumb.
+    const rsp = await superagent.get(this.baseUrl)
+    if (rsp.status !== 200) {
+      console.error(rsp)
+      return
+    }
+
+    const { hash, available } = rsp.body
+
+    this.__rpcAvailable = available
+    if (this.firstKnownHash == null) {
+      this.firstKnownHash = hash
+    }
+
+    this.recentHash = hash
+
+    // just kinda prefill. none of these get called anyway.
+    // and don't matter in prod either.
+    for (let { name } of available) {
+      this.rpc[name] = async () => {}
+    }
+  }
+
+  call (fn: string, ...args: any[]): mixed {
+    // console.debug('rpc call:', { fn, args })
+    if (this.retry) {
+      return this.callWithRetry(fn, ...args)
+    } else {
+      return this.callAsNormal(fn, ...args)
+    }
+  }
+
+  async callWithRetry (fn: string, ...args: any[]): mixed {
+    return retry<mixed>(async (bail) => {
+      try {
+        return await this.callAsNormal(fn, ...args)
+      } catch (e) {
+        if (e instanceof RPCError) {
+          bail(e)
+        }
+      }
+    })
+  }
+
+  async callAsNormal (fn: string, ...args: any[]): mixed {
+    const req: RPCRequest = { fn, args }
+    const rq = superagent.post(this.baseUrl).set({ ...this.headerMixins })
+
+    if (this.cookieHeader != null && this.cookieHeader !== '') {
+      rq.cookies = this.cookieHeader
+    }
+
+    const rsp = await rq.send(req).ok(() => true)
+    const body: RPCResponse = rsp.body
+
+    // console.log(body)
+    if (body.error === true) {
+      console.error(body)
+      throw RPCError.fromResponse(body, rsp.status)
+    }
+
+    if (body.hash != null) {
+      if (this.firstKnownHash == null) {
+        this.firstKnownHash = body.hash
+      }
+
+      this.recentHash = body.hash
+
+      if (this.firstKnownHash !== this.recentHash) {
+        this.updateCalls()
+      }
+    }
+
+    return body.response
+  }
+
+  // PROXY HANDLERS
+  // __rpcCall = (_: {}, fn: string) => this.call.bind(this, fn)
+  __rpcCall = (_: {}, fn: string) => this.call.bind(this, fn)
+  __checkCall = (_: {}, fn: string) => this.dev ? this.__listCalls(_).includes(fn) : true
+  __listCalls = (_: {}): string[] => this.__rpcAvailable.map(x => x.name)
+}