attach errorhandler to failed calls and failed connects

package.json

 {
   "name": "rpclibrary",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "rpclibrary is a websocket on steroids!",
   "main": "./js/Index.js",
   "repository": {

src/Backend.ts

     SubResType = {},
     InterfaceT extends T.RPCInterface = T.RPCInterface,
 > implements I.Destroyable{
+    
     private ws = http.createServer()
     private io = bsock.createServer()
     private visibility:T.Visibility

src/Frontend.ts

     }
 
     private socket: I.Socket
-    private closeHandlers: T.CloseHandler[] = []
-    private errorHandlers: T.ErrorHandler[] = []
+    private closeHandlers: T.FrontEndHandlerType['close'][] = []
+    private errorHandlers: T.FrontEndHandlerType['error'][] = []
     private hooks : {[name in string]: T.AnyFunction} = {} 
 
     /**
      * @param type 'error' or 'close'
      * @param f The listener to attach
      */
-    public on<T extends "error" | "close">(type: T, f: T.HandlerType[T]){
+    public on<T extends "error" | "close">(type: T, f: T.FrontEndHandlerType[T]){
         if(!this.socket){
             switch(type){
-                case "error": this.errorHandlers.push(<T.HandlerType['error']> f); break;
-                case "close": this.closeHandlers.push(<T.HandlerType['close']> f); break;
+                case "error": this.errorHandlers.push(<T.FrontEndHandlerType['error']> f); break;
+                case "close": this.closeHandlers.push(<T.FrontEndHandlerType['close']> f); break;
                 default: throw new Error('socket.on only supports ´error´ and ´close´ as first parameter. Got: ´'+type+'´')
             }
         }else{
         }
     }
 
+    /**
+     * Emit a LOCAL event
+     * @param eventName The event name to emit under
+     * @param data The data the event carries
+     */
+    public emit(eventName:string, data:any){
+        if(!this.socket) return
+        this.socket.emit(eventName, data)
+    }
+
     /**
      * Destroys the socket
      */
      */
     public async call (rpcname: string, ...args: any[]) : Promise<any>{
         if(!this.socket) throw new Error("The socket is not connected! Use socket.connect() first")
-        return await this.socket.call.apply(this.socket, [rpcname, ...args])
+        try{
+            return await this.socket.call.apply(this.socket, [rpcname, ...args])
+        }catch(e){
+            this.emit('error', e)
+        }
     }
 
     /**
         const argParams = fnArgs.map(stripAfterEquals).join(",")
         sesame = appendComma(sesame)
 
-        return eval(`async (${headerArgs}) => { return await this.socket.call("${fnName}", ${sesame} ${argParams})}`)
+        return eval(`async (${headerArgs}) => { 
+            return await this.socket.call("${fnName}", ${sesame} ${argParams})
+        }`)
     }
 
     /**
 
         return eval( `
         async (${headerArgs} callback) => {
-
             const r = await this.socket.call("${fnName}", ${sesame} ${argParams})
             if(r && r.result === 'Success'){
                 this.socket.hook(r.uuid, callback)

src/Interfaces.ts

     unhook: (rpcname:string) => void
     call: (rpcname:string, ...args: any[]) => Promise<any>
     fire: (rpcname:string, ...args: any[]) => Promise<any>
-    on: T.OnFunction    
+    on: T.OnFunction
+    emit: (eventName: string, data:any) => void    
     close() : void
 }
 

src/Types.ts

 export type SesameConf = {
     sesame?: string | SesameFunction
 }
-export type HandlerType = {
-    'error' : ErrorHandler
-    'close' : CloseHandler
+export type FrontEndHandlerType = {
+    'error' : (e: any) => void
+    'close' : () => void
 }
 
 export type ServerConf = {
 export type RpcInfo = HookInfo |  CallInfo
 export type ExtendedRpcInfo = RpcInfo & { uniqueName: string } 
 
-export type OnFunction = <T extends "error" | "close">(type: T, f: HandlerType[T]) => void
+export type OnFunction = <T extends "error" | "close">(type: T, f: FrontEndHandlerType[T]) => void
 export type HookCloseFunction<T = {}> = (res:SubscriptionResponse<T>, rpc:HookRPC<any, any, T>) => any

test/Test.ts

 
     }
     let serv: RPCServer,
-        sock: RPCSocket,
+        sock: RPCSocket & myExporterIfc,
         exporter: MyExporter
         
     before((done)=>{
         exporter = new MyExporter()
         serv = new RPCServer(21004, [exporter])
-        sock = new RPCSocket(21004, 'localhost')
-        sock.connect<myExporterIfc>().then(_ => done())
+        const s = new RPCSocket(21004, 'localhost')
+        s.connect<myExporterIfc>().then(conn => {
+            sock = conn
+            done()
+        })
     })
     after(() => {
         sock.destroy()
 
 
 describe("attaching handlers before connecting", ()=>{
-
-
     it("fires error if server is unreachable", (done)=>{
         const sock = new RPCSocket(21004, 'localhost')
         let errorHandleCount = 0
 
-        sock.on('error', (socket) => {
+        sock.on('error', (err) => {
             //attached listener fires first
             if(errorHandleCount != 0){
                 console.log("Error handler didn't fire first");
             }
         })
     })
+
+    it("fires error if call is unknown", (done)=>{
+        const serv = new RPCServer(21004)
+        const sock = new RPCSocket(21004, 'localhost')
+
+        sock.on('error', (err) => {
+            sock.destroy()
+            serv.destroy()
+            done()
+        })
+
+        sock.connect().then(_ => {
+            sock.call("unknownRPC123", "AAAAA").catch(e => {
+                console.log("unexpected call catch clause");
+                done(e)
+            })
+        }).catch(e => {
+            console.log("unexpected connect catch clause");
+            done(e)
+        })
+    })
+
+    it("demands catch on method invocation if call is unknown", (done)=>{
+        const serv = new RPCServer(21004)
+        const sock = new RPCSocket(21004, 'localhost')
+
+        sock.connect().then(_ => {
+            sock.call("unknownRPC123", "AAAAA").catch(e => {
+                sock.destroy()
+                serv.destroy()
+                done()
+            })
+        }).catch(e => {
+            console.log("unexpected connect catch clause");
+            done(e)
+        })
+    })
 })