tempalte strings & bugfixes

src/Frontend.ts

 
 import * as T from './Types'; 
 import * as I from './Interfaces';
-import { stripAfterEquals } from './Utils';
+import { stripAfterEquals, appendComma } from './Utils';
 
 
 
     private callGenerator(fnName: string, fnArgs:string[], sesame?:string): T.AnyFunction{
         const headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
-        if(!sesame)
-            return eval( '( () => async ('+headerArgs+') => { return await this.socket.call("'+fnName+'", '+argParams+')} )()' )
-        else 
-            return eval( '( () => async ('+headerArgs+') => { return await this.socket.call("'+fnName+'", "'+sesame+'", '+argParams+')} )()' )
+        sesame = appendComma(sesame)
+
+        return eval(`async (${headerArgs}) => { return await this.socket.call("${fnName}", ${sesame} ${argParams})}`)
     }
 
     /**
      */
     private frontEndHookGenerator(fnName: string, fnArgs:string[], sesame?:string): T.HookFunction{
         fnArgs.pop()
-        const headerArgs = fnArgs.join(",")
+        let headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
-
-        if(!sesame){
-            return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
-                const r = await this.socket.call("`+fnName+`", `+argParams+`)
-                if(r && r.result === 'Success'){
-                    this.socket.hook(r.uuid, callback)
-                }
-                return r
-            } )()` )
-        }else{
-            return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
-                const r = await this.socket.call("`+fnName+`", "`+sesame+`", `+argParams+`)
-                if(r && r.result === 'Success'){
-                    this.socket.hook(r.uuid, callback)
-                }
-                return r
-            } )()` )
-        }
+        sesame = appendComma(sesame)
+        headerArgs = appendComma(headerArgs) 
+
+        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)
+                this.socket.on('error', e => this.socket.unhook(r.uuid))
+            }
+            return r
+        }`)
     }
-}
+}

src/Utils.ts

  * @param owner The owning RPC group's name
  * @throws Error on RPC without name property
  */
-export const rpcToRpcinfo = <SubResT = {}>(rpc : T.RPC<any, any, SubResT>, owner: string, errorHandler: T.ErrorHandler, sesame?:T.SesameFunction):T.RpcInfo => {
+export const rpcToRpcinfo = <SubResT = {}>(socket: I.Socket, rpc : T.RPC<any, any, SubResT>, owner: string, errorHandler: T.ErrorHandler, sesame?:T.SesameFunction):T.RpcInfo => {
     switch (typeof rpc){
         case  "object":
             if(rpc['call']){
                     argNames: extractArgs(rpc['call']),
                     type: "Call",
                     name: rpc.name,
-                    call: sesame?async (_sesame, ...args) => {if(sesame(_sesame)) return await rpc['call'].apply({}, args); throw makeError(rpc.name)}:rpc['call'], // check & remove sesame 
+                    call: sesame?async (_sesame, ...args) => {if(sesame(_sesame)) return await rpc['call'].apply({}, args); socket.destroy()}:rpc['call'], // check & remove sesame 
                 }
             }else{
                 const generator = hookGenerator(<T.HookRPC<any, any, any>>rpc, errorHandler, sesame)
 \nUse 'funtion name(..){ .. }' syntax instead.
 \n
 \n<------------OFFENDING RPC:
-\n`+rpc.toString()+`
+\n${rpc.toString()}
 \n>------------OFFENDING RPC`)
             return {
                 owner : owner,
     const RPCs = [...exporter.exportRPCs()]
 
 
-    return RPCs.map(rpc => rpcToRpcinfo(rpc, owner, errorHandler, sesame))
+    return RPCs.map(rpc => rpcToRpcinfo(socket, rpc, owner, errorHandler, sesame))
     .map(info => {
         const suffix = makeUnique?"-"+uuidv4().substr(0,4):""
         const ret:any = info
  * @returns A {@link HookFunction}
  */
 const hookGenerator = (rpc:T.HookRPC<any, any, any>, errorHandler: T.ErrorHandler, sesameFn?: T.SesameFunction): T.HookInfo['generator'] => { 
-    const argsArr = extractArgs(rpc.hook)
+    let argsArr = extractArgs(rpc.hook)
     argsArr.pop() //remove 'callback' from the end
-    const argsStr = argsArr.join(',')
-
-    if(sesameFn){
-        const args = ['sesame', ...argsArr].join(',')
-        return eval(`(socket) => async (`+args+`) => {
-            try{
-                if(!sesameFn(sesame)) return
-                const res = await rpc.hook(`+argsStr+(argsStr.length!==0?',':'')+` (...cbargs) => {
-                    if(rpc.onCallback) rpc.onCallback.apply({}, cbargs)
-                    socket.call.apply(socket, [res.uuid, ...cbargs])
-                })
-                return res
-            }catch(e){
-                errorHandler(socket)(e, rpc.name, [`+args+`])
-            }
-        }`)
-    }
-    const args = argsArr.join(',')
-    return eval(`(socket) => async (`+args+`) => {
+    let callArgs = argsArr.join(',')
+
+    const args = sesameFn?(['sesame', ...argsArr].join(','))
+                         :callArgs
+
+    callArgs = appendComma(callArgs)
+
+    //note rpc.hook is the associated RPC, not a socket.hook
+    return eval(`
+    (socket) => async (${args}) => {
         try{
-            const res = await rpc.hook(`+args+(args.length!==0?',':'')+` (...cbargs) => {
+            if(sesameFn && !sesameFn(sesame)) return
+            const res = await rpc.hook(${callArgs} (...cbargs) => {
                 if(rpc.onCallback) rpc.onCallback.apply({}, cbargs)
                 socket.call.apply(socket, [res.uuid, ...cbargs])
             })
             return res
         }catch(e){
-            errorHandler(socket)(e, rpc.name, [`+args+`])
+            errorHandler(socket)(e, ${rpc.name}, [${args}])
         }
     }`)
 }
 
 const makeError = (callName: string) => {
-    return new Error("Unhandled Promise rejection: Call not found: "+callName+". ; Zone: <root> ; Task: Promise.then ; Value: Error: Call not found: "+callName)
+    return new Error("Call not found: "+callName+". ; Zone: <root> ; Task: Promise.then ; Value: Error: Call not found: "+callName)
 }
 
 /**
         return testSesame === sesame 
     }
 }
+
+
+export function appendComma(s?:string):string{
+    return s?`'${s}',`:"" 
+}

test/Test.ts

 describe('RPCServer', () => {
     let server: RPCServer<{ topic: string }, any>
 
-    before((done) => {
+    before(() => {
         server = makeServer()
-        done()
     })
     
-    after(async() => {
-        await server.destroy()
+    after(() => {
+        server.destroy()
     })
 
     it('should be able to use all kinds of RPC definitions', (done) => {
     let server: RPCServer 
     let cb = (...args) => {}
 
-    before(async() => {
+    before((done) => {
         server = new RPCServer(21004, [{
             name: "test",
             exportRPCs: () => [
             sesame: (_sesame) => _sesame === 'sesame!' 
         })
         const sock = new RPCSocket(21004, "localhost")
-        client = await sock.connect<SesameTestIfc>('sesame!')
+        sock.connect<SesameTestIfc>('sesame!').then(cli => {
+            client = cli
+            done() 
+        })
     })
 
     after(() => {
 
     it('should not work without sesame', (done) => {
         const sock = new RPCSocket(21004, "localhost")
-        sock.connect<SesameTestIfc>( /* no sesame */).then(async (c) => {
-            c.test.checkCandy().then(d => {
-                done()
+        sock.connect<SesameTestIfc>( /* no sesame */).then(async (cli) => {
+            cli.test.checkCandy().then(d => {
+                done(d)
             }).catch(e => {
                 //console.log("EXPECTED CLIENT EXCEPTION", String(e));
                 done()
             }).finally(() => {
+                cli.destroy()
                 sock.destroy()
             })
         })
 
     it('should fail with wrong sesame', (done) => {
         const sock = new RPCSocket(21004, "localhost")
-        sock.connect<SesameTestIfc>('abasd').then(async (c) => {
-            c.test.checkCandy().then(d => {
+        sock.connect<SesameTestIfc>('abasd').then(async (cli) => {
+            cli.test.checkCandy().then(d => {
                 done("should not be able to get candy")
             }).catch(e => {
                 //console.log("EXPECTED CLIENT EXCEPTION", String(e));
                 done()
             }).finally(() => {
                 sock.destroy()
+                cli.destroy()
             })
         })
     })
 
     it('callback should not work without sesame', (done) => {
         const sock = new RPCSocket(21004, "localhost")
-        sock.connect<SesameTestIfc>( /* no sesame */).then(async (c) => {
-            c.test.subscribe((c) => {
+        sock.connect<SesameTestIfc>( /* no sesame */).then(async (cli) => {
+            cli.test.subscribe((c) => {
                 console.log("CALLBACK TRIGGERED UNEXPECTED");
                 
                 if(c === candy)
                 await client.test.checkCandy()
                 if(d == null){
                     done()
+
                 }else
                     done('unexpected valid response '+(d) )
-                c.destroy()
+            }).finally(() => {
+                sock.destroy()
             })
         })
     })
 })
 
 
-
 describe('Error handling', ()=>{
     
     let createUser = async( user: {a:any,b:any}) => {
                 done()
             })
             .finally(() => {
+                cli.destroy()
                 sock.destroy()
                 server.destroy()
             })
                 done(e)
             })
             .finally(() => {
+                cli.destroy()
                 sock.destroy()
                 server.destroy()
             })
     })
 })
 
+
 describe("Errorhandler functionality", ()=>{
     let createUser = async( user: {a:any,b:any}) => {
         throw new Error("BAD BAD BAD")
                 done(e)
             })
             .finally(() => {
+                cli.destroy()
                 sock.destroy()
                 server.destroy()
             })
                 done(e)
             })
             .finally(() => {
+                cli.destroy()
                 sock.destroy()
                 server.destroy()
             })