remove unhook

src/Backend.ts

         if(!conf.errorHandler) this.errorHandler = 
         (socket:I.Socket) => (error:any) => { 
             socket.destroy(); 
-            console.error(error) 
+            console.error("Caught websocket error", String(error)) 
         }
         
         if(!conf.closeHandler) this.closeHandler = 
         
         if(!conf.connectionHandler) this.connectionHandler = 
         (socket:I.Socket) => { 
-            console.log("New websocket connection in port "+socket.port)
+            console.log("New websocket connection on port "+socket.port)
         }
 
         let badRPC 

src/Frontend.ts

                 case 'Hook':
                     f = this.hookGenerator(i.uniqueName, i.argNames)                    
                     break
-                case 'Unhook':
-                    f = this.unhookGenerator(i.uniqueName, i.argNames)                    
-                    break
             }
             if(this[i.owner] == null)
                 this[i.owner] = {}
         return eval( '( () => async ('+headerArgs+') => { return await this.socket.call("'+fnName+'", '+argParams+')} )()' )
     }
 
-    private hookGenerator(fnName: T.Name, fnArgs:T.Arg[]): T.CallbackFunction{
+    private hookGenerator(fnName: T.Name, fnArgs:T.Arg[]): T.HookFunction{
         const headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
         return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
                             return r
                         } )()` )
     }
-
-    private unhookGenerator(fnName: T.Name, fnArgs:T.Arg[]): T.UnhookFunction{
-        const headerArgs = fnArgs.join(",")
-        const argParams = fnArgs.map(stripAfterEquals).join(",")
-        if(fnArgs.length != 1)
-            console.error("UnhookFunction", fnName, "specified more than one argument: ("+headerArgs+")")
-
-        return eval( `( () => async (`+headerArgs+`) => {
-                            const r = await this.socket.call("`+fnName+`", `+argParams+`)
-                            this.socket.unhook(`+argParams+`)
-                            return r
-                        } )()` )
-    }
-
 }

src/Types.ts

 
 export type HookRPC = BaseRPC & {
     type: 'Hook'
-    hook: CallbackFunction
-    unhook: UnhookFunction
-}
-
-export type UnhookRPC = BaseRPC & {
-    type: 'Unhook'
-    unhook: UnhookFunction
+    hook: HookFunction
+    onCallback?: CallbackFunction,
+    onClose?: HookCloseFunction
 }
 
 export type CallRPC = (BaseRPC & {
     call: AsyncFunction
 } ) | Function
 
-export type RPC = CallRPC | UnhookRPC | HookRPC
+export type RPC = CallRPC | HookRPC
 
 export type BaseInfo = {
     owner: Name,
 
 export type HookInfo = BaseRPC & BaseInfo & { 
     type: 'Hook', 
-    generator: (socket) => CallbackFunction
-    unhook: UnhookFunction
-}
-
-export type UnhookInfo = BaseRPC & BaseInfo & {
-    type: 'Unhook',
-    unhook: UnhookFunction
+    generator: (socket) => HookFunction
 }
 
 export type CallInfo = BaseRPC & BaseInfo & {
     call: AsyncFunction
 }
 
-export type RpcInfo = HookInfo | UnhookInfo | CallInfo
+export type RpcInfo = HookInfo |  CallInfo
 export type ExtendedRpcInfo = RpcInfo & { uniqueName: string } 
 
 export type OnFunction = (type: 'error' | 'close', f: (e?:any)=>void) => I.Socket
-export type UnhookFunction = (uid:string) => Promise<R.SuccessResponse | R.ErrorResponse>
-export type CallbackFunction = (...args) => Promise<R.SubscriptionResponse | R.ErrorResponse>
-export type AsyncFunction = (...args) => Promise<any>
+export type HookCloseFunction = (res:R.SubscriptionResponse) => any
+export type HookFunction = (...args:any[]) => Promise<R.SubscriptionResponse | R.ErrorResponse>
+export type AsyncFunction = (...args:any[]) => Promise<any>
+export type CallbackFunction = (arg: any) => void

src/Utils.ts

                     name: rpc.name,
                     call: rpc.call,
                 }
-            case "Unhook" :
-                return {
-                    owner: owner,
-                    argNames: extractArgs(rpc.unhook),
-                    type: rpc.type,
-                    name: rpc.name,
-                    unhook: rpc.unhook,
-                }
             case "Hook" :
                 const generator = hookGenerator(rpc)
                 return {
                     argNames: extractArgs(generator(undefined)),
                     type: rpc.type,
                     name: rpc.name,
-                    unhook: rpc.unhook,
                     generator: generator,
+                    
                 }
         }
         break;
             case "Hook":
                 socket.hook(ret.uniqueName, info.generator(socket))
                 break;
-            case "Unhook":
-                socket.hook(ret.uniqueName, info.unhook)
-                break;
             case "Call":
                 socket.hook(ret.uniqueName, info.call)
                 break;
     const args = argsArr.join(',')
 
     return eval(`(socket) => async (`+args+`) => { 
-        const res = await rpc.hook(`+args+(args.length!==0?',':'')+` (x) => {
-            socket.call(res.uid, x)
+        const res = await rpc.hook(`+args+(args.length!==0?',':'')+` (...cbargs) => {
+            if(rpc.onCallback) rpc.onCallback.apply({}, cbargs)
+            socket.call.apply(socket, [res.uid, ...cbargs])
         })
         if(res.result == 'Success'){
+            if(rpc.onClose)
             socket.on('close', async () => {
-                const unhookRes = await rpc.unhook(res.uid)
-                console.log("Specific close handler for", rpc.name, res.uid, unhookRes)
+                rpc.onClose(res)
             })
         }
         return res
 }
 
 const extractArgs = (f:Function):T.Arg[] => {
-    let fn = String(f)
-    let args = fn.substr(0, fn.indexOf(")"))
-    args = args.substr(fn.indexOf("(")+1)
-    let ret = args.split(",")
-    return ret
+    let fn
+    return (fn = String(f)).substr(0, fn.indexOf(")")).substr(fn.indexOf("(")+1).split(",")
 }

test/TestBackend.ts

 import { RPCServer } from '../src/Backend'
-import { SubscriptionResponse } from '../src/Responses'
+import { SubscriptionResponse, ErrorResponse, SuccessResponse } from '../src/Responses'
+import { HookRPC } from '../src/Types'
 
 let subcallback
 
             subcallback = callback
             return new SubscriptionResponse(""+Math.random())
         },
-        unhook: async (uid):Promise<any> => { subcallback = null }
+        onClose: (res:SubscriptionResponse) => { 
+            console.log("Specific close handler for", res)
+            subcallback = null 
+        }
     },
     function add(...args:number[]):number {return args.reduce((a,b)=>a+b, 0)},
-    function triggerCallback(message):number {return subcallback(message)},
+    function triggerCallback(...messages:any[]):number {return subcallback.apply({}, messages)},
 ]
 }])
 
         ]
     }])
 }catch(badRPCError){
-    console.log("expected bad-RPC error happened: "+ !!badRPCError)
+    console.log("expected bad-RPC error happened: "+ !!badRPCError, String(badRPCError))
 }

test/TestFrontend.ts

     }
 
     await client["HelloWorldRPCGroup"].subscribe(handler)
-    client["HelloWorldRPCGroup"].triggerCallback("test1")
-    client["HelloWorldRPCGroup"].triggerCallback("test2")
-    client["HelloWorldRPCGroup"].triggerCallback("test3")
+    client["HelloWorldRPCGroup"].triggerCallback("test1", "test1", "test1", )
+    client["HelloWorldRPCGroup"].triggerCallback("test2", "test2", "test2", )
+    client["HelloWorldRPCGroup"].triggerCallback("test3", "test3", "test3", )
 })