UI and Server API review - Messages

[naleeha]

Objective

• Consistent naming
• Consider how to report error where UI can handle generically with specific actions (e.g. error pop up?)
• Simpler types/less variety?
• Document expected scenario based flows

Current

See Messages.scala and CoreJsonSerializationMixin.scala
or vuu-protocal-types\index.d.ts

Parent Message object

JsonViewServerMessage(
                                  requestId: String, //set except for login request + response where it is empty, Heartbeat where it is NA, table row update where its is empty
                                  sessionId: String, // set except login request as created by server and returned in response
                                  token: String, // set except heartbeat request from ui, should this be visible?
                                  user: String, 
                                  body: MessageBody, 
                                  module: String = "CORE")  //always seem to be the default value- only usage might be for resolving appropriate global rpc handler

Message Body types

Authenticate
TO BE REMOVED

AuthenticateRequest(username: String, password: String)

AuthenticateSuccess(token: String)
AuthenticateFailure(msg: String)

Login

LoginRequest(token: String, user: String)

LoginSuccess(token: String)
LoginFailure(token: String, errorMsg: String) 
    // why does these response return token that was passed in the request? Does UI use this or match based on message request id?

Heartbeat
Heartbeat request is initiated from server, and client sends response

HeartBeat(ts: Long)
HeartBeatResponse(ts: Long)

Get Table List

GetTableList()

GetTableListResponse(tables: Array[ViewPortTable])

ViewPortTable

ViewPortTable(table: String, module: String)

Get Table Meta

GetTableMetaRequest(table: ViewPortTable)

GetTableMetaResponse(table: ViewPortTable, columns: Array[String], dataTypes: Array[String], key: String)
//returns ErrorResponse if fail

RCP

RpcCall(service: String, method: String, params: Array[Any], namedParams: Map[String, Any])

RpcResponse(method: String, result: Any, error: Error)

Error

Error(message: String, code: Int)

RPC Update

RpcUpdate(table: ViewPortTable, key: String, data: Map[String, Any])

RpcSuccess(table: ViewPortTable, key: String)
RpcReject(table: ViewPortTable, key: String, reason: String)

Viewport RCP

ViewPortRpcCall(vpId: String, rpcName: String, params: Array[Any], namedParams: Map[String, Any])  

ViewPortRpcResponse(vpId: String, method: String, action: ViewPortAction)
// returns ViewPortMenuRpcReject if error

Viewport Menu RCP

ViewPortMenuSelectionRpcCall(vpId: String, rpcName: String)
ViewPortMenuCellRpcCall(vpId: String, rpcName: String, rowKey: String, field: String, value: Object)
ViewPortMenuRowRpcCall(vpId: String, rpcName: String, rowKey: String, row: Map[String, Object])
ViewPortMenuTableRpcCall(vpId: String, rpcName: String)

ViewPortMenuRpcResponse(vpId: String, rpcName: String, action: ViewPortAction)
ViewPortMenuRpcReject(vpId: String, rpcName: String, error: String) 

Menu RPC
TO BE REMOVED

MenuRpcCall(module: String, method: String, params: Array[Any], namedParams: Map[String, Any])

MenuRpcResponse(module: String, method: String, result: ViewPortAction)

Viewport Edit RCP

ViewPortEditCellRpcCall(vpId: String, rowKey: String, field: String, value: Object) // this currently return ViewPortMenuRpcResponse or ViewPortMenuRpcReject

ViewPortEditRowRpcCall(vpId: String, rowKey: String, data: Map[String, Object])
ViewPortAddRowRpcCall(vpId: String, rowKey: String, data: Map[String, Any])
ViewPortDeleteRowRpcCall(vpId: String, rowKey: String)
ViewPortDeleteCellRpcCall(vpId: String, rowKey: String, field: String)

ViewPortEditSubmitFormRpcCall(vpId: String)
ViewPortEditCloseFormRpcCall(vpId: String, field: String, value: Object)

ViewPortEditRpcResponse(vpId: String, rpcName: String, action: ViewPortAction)
ViewPortEditRpcReject(vpId: String, rpcName: String, error: String)

ViewPortAction

NoAction()
OpenDialogViewPortAction(table: ViewPortTable, renderComponent: String = "grid")
CloseDialogViewPortAction(vpId: String)
ViewPortRpcSuccess() //TO BE REMOVED
ViewPortRpcFailure(msg: String) //TO BE REMOVED
ViewPortCreateSuccess(key:String) //TO BE REMOVED

Error

ErrorResponse(msg: String)

Create Viewport

CreateViewPortRequest(
                       table: ViewPortTable,
                       range: ViewPortRange,
                       columns: Array[String],
                       sort: SortSpec = SortSpec(List()),
                       groupBy: Array[String] = Array(),
                       filterSpec: FilterSpec = null,
                       aggregations: Array[Aggregations] = Array())

CreateViewPortSuccess(
                       viewPortId: String, 
                       able: String,
                       range: ViewPortRange,
                       columns: Array[String], 
                       sort: SortSpec = SortSpec(List()),
                       groupBy: Array[String] = Array(),
                       filterSpec: FilterSpec = null,
                       aggregations: Array[Aggregations] = Array())
CreateViewPortReject(table: ViewPortTable,
                                msg: String)

SortSpec(sortDefs: List[SortDef]) // there is SortSpecInternal for internal use but the conversion need to happen before calling internal functions
SortDef(column: String, sortType: Char)

FilterSpec(filter: String) //also internal model 

AggregationSpec(aggregationType: String, column: String)
Aggregations(column: String, aggType: Int)

GroupBySpec(columns: Array[String], aggregations: List[AggregationSpec] = List()) //not used

ViewPortRange(from: Int, to: Int)  //also internal model

Deleting Viewport

RemoveViewPortRequest(viewPortId: String)

RemoveViewPortSuccess(viewPortId: String)

Change Viewport Content

ChangeViewPortRequest(
                      viewPortId: String, 
                      columns: Array[String], 
                      sort: SortSpec = SortSpec(List()), 
                      groupBy: Array[String] = Array(), 
                      filterSpec: FilterSpec = null, 
                      aggregations: Array[Aggregations] = Array())

ChangeViewPortSuccess(
                       viewPortId: String, 
                       columns: Array[String],
                       sort: SortSpec = SortSpec(List()),
                       groupBy: Array[String] = Array(),
                       filterSpec: FilterSpec = null,
                       aggregations: Array[Aggregations] = Array())
ChangeViewPortReject(
                      viewPortId: String, 
                      msg: String)

Change Viewport Range

ChangeViewPortRange(viewPortId: String, from: Int, to: Int)

ChangeViewPortRangeSuccess(viewPortId: String, from: Int, to: Int)
//returns ErrorResponse if fail

Set Selection
Expects indices of selected rows - what happen if index change?

SetSelectionRequest(vpId: String, selection: Array[Int])

SetSelectionSuccess(vpId: String, selection: Array[Int]) 
//returns ErrorResponse if fail

Get Viewport Menu

GetViewPortMenusRequest(vpId: String)

GetViewPortMenusResponse(vpId: String, menu: ViewPortMenu)
//returns ErrorResponse if fail

Viewport Menu

ViewPortMenuFolder(val name: String, val menus: Seq[ViewPortMenu])
EmptyViewPortMenu //is this expected to be sent between ui and server?

//Menu Items match based on context 
selected-rows - SelectionViewPortMenuItem(val name: String, val filter: String, val rpcName: String)
row - RowViewPortMenuItem(val name: String, val filter: String, val rpcName: String)
grid - TableViewPortMenuItem(val name: String, val filter: String, val rpcName: String)
cell - CellViewPortMenuItem(val name: String, val filter: String, val rpcName: String, val field: String)

Create Visual Link

CreateVisualLinkRequest(childVpId: String, parentVpId: String, childColumnName: String, parentColumnName: String)

CreateVisualLinkSuccess(childVpId: String, parentVpId: String, childColumnName: String, parentColumnName: String)
//returns ErrorResponse if fail

Remove Visual Link

RemoveVisualLinkRequest(childVpId: String)

RemoveVisualLinkSuccess(childVpId: String)
//returns ErrorResponse if fail

Get Visual Links

GetViewPortVisualLinksRequest(vpId: String)

GetViewPortVisualLinksResponse(vpId: String, links: List[AvailableViewPortVisualLink])
//returns ErrorResponse if fail

Enable Viewport

EnableViewPortRequest(viewPortId: String)

EnableViewPortSuccess(viewPortId: String)
EnableViewPortReject(viewPortId: String)

Disable Viewport

DisableViewPortRequest(viewPortId: String)

DisableViewPortSuccess(viewPortId: String)
DisableViewPortReject(viewPortId: String)

Open Tree Node

OpenTreeNodeRequest(vpId: String, treeKey: String)

OpenTreeNodeSuccess(vpId: String, treeKey: String) 
OpenTreeNodeReject(vpId: String, treeKey: String)  //not used

Close Tree Node

CloseTreeNodeRequest(vpId: String, treeKey: String)

CloseTreeNodeSuccess(vpId: String, treeKey: String)
CloseTreeNodeReject(vpId: String, treeKey: String) // not used

Type field

  new Type(value = classOf[AuthenticateRequest], name = "AUTH"),
  new Type(value = classOf[CreateViewPortRequest], name = "CREATE_VP"),
  new Type(value = classOf[DisableViewPortRequest], name = "DISABLE_VP"),
  new Type(value = classOf[DisableViewPortSuccess], name = "DISABLE_VP_SUCCESS"),
  new Type(value = classOf[DisableViewPortReject], name = "DISABLE_VP_REJECT"),
  new Type(value = classOf[EnableViewPortRequest], name = "ENABLE_VP"),
  new Type(value = classOf[EnableViewPortSuccess], name = "ENABLE_VP_SUCCESS"),
  new Type(value = classOf[EnableViewPortReject], name = "ENABLE_VP_REJECT"),
  new Type(value = classOf[RemoveViewPortRequest], name = "REMOVE_VP"),
  new Type(value = classOf[RemoveViewPortSuccess], name = "REMOVE_VP_SUCCESS"),
  new Type(value = classOf[RemoveViewPortReject], name = "REMOVE_VP_REJECT"),
  new Type(value = classOf[CreateViewPortSuccess], name = "CREATE_VP_SUCCESS"),
  new Type(value = classOf[CreateViewPortReject], name = "CREATE_VP_REJECT"),
  new Type(value = classOf[ChangeViewPortRange], name = "CHANGE_VP_RANGE"),
  new Type(value = classOf[ChangeViewPortRangeSuccess], name = "CHANGE_VP_RANGE_SUCCESS"),
  new Type(value = classOf[ChangeViewPortRequest], name = "CHANGE_VP"),
  new Type(value = classOf[ChangeViewPortSuccess], name = "CHANGE_VP_SUCCESS"),
  new Type(value = classOf[ChangeViewPortReject], name = "CHANGE_VP_REJECT"),
  new Type(value = classOf[AuthenticateSuccess], name = "AUTH_SUCCESS"),
  new Type(value = classOf[AuthenticateFailure], name = "AUTH_FAIL"),
  new Type(value = classOf[LoginRequest], name = "LOGIN"),
  new Type(value = classOf[LoginSuccess], name = "LOGIN_SUCCESS"),
  new Type(value = classOf[LoginFailure], name = "LOGIN_FAIL"),
  new Type(value = classOf[TableRowUpdates], name = "TABLE_ROW"),
  new Type(value = classOf[OpenTreeNodeRequest], name = "OPEN_TREE_NODE"),
  new Type(value = classOf[CloseTreeNodeRequest], name = "CLOSE_TREE_NODE"),
  new Type(value = classOf[GetTableMetaRequest], name = "GET_TABLE_META"),
  new Type(value = classOf[GetTableMetaResponse], name = "TABLE_META_RESP"),
  new Type(value = classOf[GetTableList], name = "GET_TABLE_LIST"),
  new Type(value = classOf[GetTableListResponse], name = "TABLE_LIST_RESP"),
  new Type(value = classOf[HeartBeat], name = "HB"),
  new Type(value = classOf[RpcUpdate], name = "RPC_UP"),
  new Type(value = classOf[RpcSuccess], name = "RPC_SUCCESS"),
  new Type(value = classOf[RpcReject], name = "RPC_REJECT"),
  new Type(value = classOf[HeartBeatResponse], name = "HB_RESP"),
  new Type(value = classOf[RpcCall], name = "RPC_CALL"),
  new Type(value = classOf[ViewPortRpcCall], name = "VIEW_PORT_RPC_CALL"),
  new Type(value = classOf[ViewPortRpcResponse], name = "VIEW_PORT_RPC_REPONSE"),
  new Type(value = classOf[MenuRpcCall], name = "MENU_RPC_CALL"),
  new Type(value = classOf[MenuRpcResponse], name = "MENU_RPC_RESP"),
  new Type(value = classOf[RpcResponse], name = "RPC_RESP"),
  new Type(value = classOf[OpenTreeNodeSuccess], name = "OPEN_TREE_SUCCESS"),
  new Type(value = classOf[OpenTreeNodeReject], name = "OPEN_TREE_REJECT"),
  new Type(value = classOf[CloseTreeNodeSuccess], name = "CLOSE_TREE_SUCCESS"),
  new Type(value = classOf[CloseTreeNodeReject], name = "CLOSE_TREE_REJECT"),
  new Type(value = classOf[SetSelectionRequest], name = "SET_SELECTION"),
  new Type(value = classOf[SetSelectionSuccess], name = "SET_SELECTION_SUCCESS"),
  new Type(value = classOf[ErrorResponse], name = "ERROR"),
  new Type(value = classOf[GetViewPortVisualLinksRequest], name = "GET_VP_VISUAL_LINKS"),
  new Type(value = classOf[GetViewPortVisualLinksResponse], name = "VP_VISUAL_LINKS_RESP"),
  new Type(value = classOf[CreateVisualLinkRequest], name = "CREATE_VISUAL_LINK"),
  new Type(value = classOf[CreateVisualLinkSuccess], name = "CREATE_VISUAL_LINK_SUCCESS"),
  new Type(value = classOf[GetViewPortMenusRequest], name = "GET_VIEW_PORT_MENUS"),
  new Type(value = classOf[GetViewPortMenusResponse], name = "VIEW_PORT_MENUS_RESP"),
  new Type(value = classOf[ViewPortMenuSelectionRpcCall], name = "VIEW_PORT_MENUS_SELECT_RPC"),
  new Type(value = classOf[ViewPortMenuTableRpcCall], name = "VIEW_PORT_MENU_TABLE_RPC"),
  new Type(value = classOf[ViewPortMenuRowRpcCall], name = "VIEW_PORT_MENU_ROW_RPC"),
  new Type(value = classOf[ViewPortMenuCellRpcCall], name = "VIEW_PORT_MENU_CELL_RPC"),
  new Type(value = classOf[ViewPortMenuRpcResponse], name = "VIEW_PORT_MENU_RESP"),
  new Type(value = classOf[ViewPortMenuRpcReject], name = "VIEW_PORT_MENU_REJ"),
  new Type(value = classOf[RemoveVisualLinkRequest], name = "REMOVE_VISUAL_LINK"),
  new Type(value = classOf[RemoveVisualLinkSuccess], name = "REMOVE_VISUAL_LINK_SUCCESS"),
  new Type(value = classOf[ViewPortEditRowRpcCall], name = "VP_EDIT_ROW_RPC"),
  new Type(value = classOf[ViewPortEditCellRpcCall], name = "VP_EDIT_CELL_RPC"),
  new Type(value = classOf[ViewPortEditSubmitFormRpcCall], name = "VP_EDIT_SUBMIT_FORM_RPC"),
  new Type(value = classOf[ViewPortEditCloseFormRpcCall], name = "VP_EDIT_CLOSE_FORM_RPC"),
  new Type(value = classOf[ViewPortDeleteCellRpcCall], name = "VP_EDIT_DELETE_CELL_RPC"),
  new Type(value = classOf[ViewPortDeleteRowRpcCall], name = "VP_EDIT_DELETE_ROW_RPC"),
  new Type(value = classOf[ViewPortAddRowRpcCall], name = "VP_EDIT_ADD_ROW_RPC"),
  new Type(value = classOf[ViewPortEditRpcReject], name = "VP_EDIT_RPC_REJECT"),
  new Type(value = classOf[ViewPortEditRpcResponse], name = "VP_EDIT_RPC_RESPONSE")

[naleeha]

Use cases to consider

• Need to return ViewPort RPC with a result object for Type ahead usecase (current no such ViewPortAction defined) Use view port columns in type ahead rather than table columns #1434
• Need to support new view port action where you can show notification new action type for Menu RPC responses #1443
• Need a way to report error when user actions crashes the app Error during user action currently crashes the app #1291

Areas to address

• Consistent way to report error
• How to specify next action - When is this needed? should that be ui decision or server decision? e.g. return view port action vs error type?
• How to return successful result
  • Some just indicates success but has some fields to map back to correct context to match the request. Some are get request that return results, some indicate next action
  • Do we want a type per request type or a generic response object with request type as a field?
• Why is there params and named params on ViewPortRpcCall
• Contract first API Websocket Contract first API #1449

[heswell]

a few initial observations

• RpcUpdate is not used from the UI
• ViewportRpcSucess, ViewportRpcFailure and ViewportCreateSucess seem out of place under ViewportAction. They are not used as actions

There are other messages which are untested, in that we have no examples that use them from UI. e.g

• ViewportAddRowRpc
• ViewportDeleteRowRpc
• ViewportEditRowRpc

Do we need both params and namedParams as alternatives on ViewportRpcCall ?

[heswell]

Menu RPC
There is code to handle this on client, but as menu code is driven from server, if there is no server usage, then the UI code will never be used. Suspect it was replaced by the VIEWPORT_MENU variants

[naleeha]

What we agreed on

• We have some core library API that is worth having a well-defined message type.
• We have some generic RPC request/response that applications that use VUU library can optionally extend
• Error response can be generic and used for all requests
• Want a way for sever to respond with optional UI actions to drive what UI do next

Next steps

• Review few options for a new view port level generic RPC messages
• Implement few use cases using the new messages - e.g. type ahead on view port level, application level rpc like cancel trade that returns show notification action
• Revisit other types of RPC message – non view port specific one, edit rpc, menu rpc
• Revisit rest of the api, clean up unused ones

Response type options

Generic error response & Request specific success response

case class GenericRpcRequest(viewportId: String, rpcName: String, params: Object) extends MessageBody
case class GenericRpcSuccessResponse(viewportId: String, rpcName: String, action: UIAction) extends MessageBody

case class GetTableList()
case class GetTableListSuccessResponse(tables: Array[ViewPortTable])

case class RpcErrorResponse(errorMessage:String, action: UIAction) extends MessageBody

Possible UI Actions

trait UIAction {}
case class NoAction() extends UIAction
case class OpenDialogAction(moduleName: String, tableName: String, renderComponent: String = "grid") extends UIAction
case class CloseDialogAction(viewportId: String) extends UIAction // is viewport id not already on the parent object?
case class DisplayResultAction(result: Any) extends UIAction
 case class ShowNotificationViewPortAction( notificationType:String, message: String, title: String ="")  extends UIAction

Example of core api

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "GET_TABLE_LIST"
  }
}

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "GET_TABLE_LIST_SUCCESS_RESPONSE",
    "tables": [ "table1", "table2"]
  }
}

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "RPC_ERROR_RESPONSE",
    "errorMessage": "do we still need this give we have action?"
    "action": {
      "type": "SHOW_NOTIFICATION_ACTION",
      "notificationType": "ERROR",
      "title": "Unrecoverable Error",
      "message": "Could not get table list - please contact application support"
    }
  }
}

Example of generic rpc

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "GENERIC_RPC_REQUEST",
    "viewportId": "fdjdjahdahj",
    "rpcName": "createBasket",
    "params": {
      "name": "MyCustomFTSETracker",
      "baseIndex" : ".FTSE"
    }
  }
}

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "GENERIC_RPC_SUCCESS_RESPONSE",
    "viewportId": "fdjdjahdahj",
    "rpcName": "createBasket",
    "action": {
      "type": "NoAction"
    }
  }
}

Single response message that can represent success or error result

case class GenericRpcRequest(viewportId: String, rpcName: String, params: Object) extends MessageBody

case class GetTableList() extends MessageBody

case class RpcResponse(viewportId: String, rpcName: String, isSuccess: Boolean, result: ResultBody) extends MessageBody
trait ResultBody {}
case class RcpSuccessResult(action: UIAction) extends ResultBody
case class RcpErrorResult(errorMessage:String, action: UIAction) extends ResultBody

Example of core api

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "GET_TABLE_LIST"
  }
}

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "RPC_RESPONSE",
    "rpcName": "getTableList",
    "isSuccess": true,
    "result": {
      "type": "RPC_SUCCESS_RESULT",
      "action": {
        "type": "DISPLAY_RESULT_ACTION",
        "result" : {
          "tables": ["table1", "table2"]
        }
      }
    }
  }
}

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "RPC_RESPONSE",
    "rpcName": "getTableList",
    "isSuccess": true,
    "result": {
      "type": "RPC_ERROR_RESULT",
      "errorMessage" : "do we need this if we return actions?",
      "action": {
        "type": "SHOW_NOTIFICATION_ACTION",
        "notificationType": "ERROR",
        "title": "Unrecoverable Error",
        "message": "Could not get table list - please contact application support"
      }
    }
  }
}

Custom Rpc example

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "GENERIC_RPC_REQUEST",
    "viewportId": "fdjdjahdahj",
    "rpcName": "createBasket",
    "params": {
      "name": "MyCustomFTSETracker",
      "baseIndex" : ".FTSE"
    }
  }
}

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "RPC_RESPONSE",
    "rpcName": "createBasket",
    "isSuccess": true, 
    "result": {
      "type": "RPC_SUCCESS_RESULT",
      "action": {
        "type": "SHOW_NOTIFICATION_ACTION",
        "notificationType": "SUCCESS",
        "title": "BASKET CREATED",
        "message": "Basket MyCustomFTSETracker created"
      }
    }
  }
}

RPC context options

We can have more granular rpc messages that is specific to context (e.g. view port id or that + row id etc) or have a context as optional field

[heswell]

In the message below, I would prefer to locate the result as a sibling of the action, rather than nest the result inside the action.
The nested result within result feels awkward, Plus semantically, I feel that the action , i.e a hint for UI about what to do is separate from the result

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "GET_TABLE_LIST"
  }
}

{
  "requestId": "ip-qHiO3cKKYvVT1LL9ow",
  "sessionId": "SESS-60d190dc-ff19-44e8-bdca-c989cfd2fff2",
  "body": {
    "type": "RPC_RESPONSE",
    "rpcName": "getTableList",
    "isSuccess": true,
    "result": {
      "type": "RPC_SUCCESS_RESULT",
      "action": {
        "type": "DISPLAY_RESULT_ACTION",
        "result" : {
          "tables": ["table1", "table2"]
        }
      }
    }
  }
}

[heswell]

one of the minor things that annoys me is the definition of Table, which is

{table: string, module: string}

which means I end up with lots of code referring to table.table could we use

{name: string, module: string}

[rumakt]

Why dont we take a step back and use the opportunity to simplify :

//
// Message envelope
{
  "MessageType" : "Event", // possible values : "Event", "Request", "Response
// Mandatory block of headers 
 "Headers" : {
    "RequestId" : "<uuid>", // mandatory
    "SessionId" : "<uuid>", // mandatory
    "OperationName" : "name" // in case of RPC call 
  },
 // Payload section, context specific, optional 
  "Payload" : { 
    // any content here
  }
}

[naleeha]

Current working proposal

Request

{
    "requestId": "REQ-3",
    "sessionId": "SESS-5a407509-387b-4f97-b59b-c0a3efbb0e8d",
    "token": "3afbe861-797e-4f38-a073-161bd544b25f",
    "user": "testUser",
    "body": {
      "type": "RPC_REQUEST",
      "context": {
        "type": "VIEWPORT_CONTEXT",
        "viewPortId": "testUser-VP-00000000"
      },
      "rpcName": "getUniqueFieldValues",
      "params": {
        "table": "TypeaheadTest",
        "module": "TEST",
        "column": "Account"
      }
    },
    "module": "DoesntReallyMatter"
  }

Successful Response

  {
    "requestId": "REQ-3",
    "sessionId": "SESS-5a407509-387b-4f97-b59b-c0a3efbb0e8d",
    "token": "3afbe861-797e-4f38-a073-161bd544b25f",
    "user": "testUser",
    "body": {
      "type": "RPC_RESPONSE",
      "rpcName": "getUniqueFieldValues",
      "result": {
        "type": "SUCCESS_RESULT",
        "data": [
          "12355",
          "45321",
          "89564"
        ]
      },
      "action": {
        "type": "NO_ACTION"
      }
    },
    "module": "CORE"
  }

Error Response

  {
    "requestId": "REQ-1",
    "sessionId": "SESS-0e3c83ce-38a5-4ce9-83b2-27a161d6d8b9",
    "token": "55f2449c-d985-408d-bf37-068e309e4437",
    "user": "testUser",
    "body": {
      "type": "RPC_RESPONSE",
      "rpcName": "getUniqueFieldValues",
      "result": {
        "type": "ERROR_RESULT",
        "errorMessage": "No viewport viewPortThatDoesNotExist found for RPC Call for getUniqueFieldValues"
      },
      "action": {
        "type": "SHOW_NOTIFICATION_ACTION",
        "notificationType": "Error",
        "title": "Failed to process getUniqueFieldValues request",
        "message": "No viewport viewPortThatDoesNotExist found for RPC Call for getUniqueFieldValues"
      }
    },
    "module": "CORE"
  }