fix subscribe+sesame

package.json

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

src/Backend.ts

         if(!conf.visibility) this.visibility = "127.0.0.1"        
         
         if(conf.sesame){
-            console.log("Setting Sesame")
             this.sesame = U.makeSesameFunction(conf.sesame)
         }
 

src/Frontend.ts

                     f = this.callGenerator(i.uniqueName, i.argNames, sesame)    
                     break                
                 case 'Hook':
-                    f = this.hookGenerator(i.uniqueName, i.argNames, sesame)                    
+                    f = this.frontEndHookGenerator(i.uniqueName, i.argNames, sesame)                    
                     break
             }
             if(this[i.owner] == null)
      * @param fnName The function name
      * @param fnArgs A string-list of parameters
      */
-    private hookGenerator(fnName: string, fnArgs:string[], sesame?:string): T.HookFunction{
+    private frontEndHookGenerator(fnName: string, fnArgs:string[], sesame?:string): T.HookFunction{
+        fnArgs.pop()
         const headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
+
         if(!sesame){
-            return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
+            const headerArgs = fnArgs.join(",")
+            const argParams = fnArgs.map(stripAfterEquals).join(",")
+
+            const f = eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
                 const r = await this.socket.call("`+fnName+`", `+argParams+`)
-                if(r.result === 'Success'){
+                if(r && r.result === 'Success'){
                     this.socket.hook(r.uuid, callback)
                 }
                 return r
             } )()` )
+            return f
         }else{
+
             return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
                 const r = await this.socket.call("`+fnName+`", "`+sesame+`", `+argParams+`)
-                if(r.result === 'Success'){
+                if(r && r.result === 'Success'){
                     this.socket.hook(r.uuid, callback)
                 }
                 return r

src/Utils.ts

     })
 }
 /**
- * Utility function to generate {@link HookFunction} from a RPC
+ * Utility function to generate {@link HookFunction} from a RPC for backend
  * @param rpc The RPC to transform
  * @returns A {@link HookFunction}
  */
-const hookGenerator = (rpc:T.HookRPC<any, any, any>, sesame?:T.SesameFunction): T.HookInfo['generator'] => { 
+const hookGenerator = (rpc:T.HookRPC<any, any, any>, sesameFn?: T.SesameFunction): T.HookInfo['generator'] => { 
     const argsArr = extractArgs(rpc.hook)
-    if(sesame){
-        const _sesame = argsArr.shift()
-        if(!sesame(_sesame!)){
-            throw new Error('Bad sesame')
-        }
-    }
     argsArr.pop() //remove 'callback' from the end
-    const args = argsArr.join(',')
+    const argsStr = argsArr.join(',')
 
-    return eval(`(socket) => async (`+args+`) => { 
+    if(sesameFn){
+        const args = ['sesame', ...argsArr].join(',')
+        const f =  eval(`(socket) => async (`+args+`) => {
+            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
+        }`)
+        return f
+    }
+    const args = argsArr.join(',')
+    return eval(`(socket) => async (`+args+`) => {
         const res = await rpc.hook(`+args+(args.length!==0?',':'')+` (...cbargs) => {
             if(rpc.onCallback) rpc.onCallback.apply({}, cbargs)
             socket.call.apply(socket, [res.uuid, ...cbargs])
         })
-        if(res.result === 'Success'){
-            if(rpc.onClose){
-                socket.on('close', async () => {
-                    rpc.onClose(res, rpc)
-                })
-            }
-        }
         return res
     }`)
 }
 
+
 /**
  * Extract a string list of parameters from a function
  * @param f The source function
     }
 }
 
+
 export function makeSesameFunction (sesame : T.SesameFunction | string) : T.SesameFunction {
     if(typeof sesame === 'function'){
         return sesame
     return (testSesame : string) => {
         return testSesame === sesame 
     }
-}
+}

test/Test.ts

-import { describe, it } from "mocha";
+import { describe, it, Func } from "mocha";
 
 import { RPCServer, RPCSocket, SubscriptionResponse, makeSubResponse } from '../Index'
 import * as uuidv4 from "uuid/v4"
 })
 
 
-type SesameTestIfc = { test: { checkCandy: ()=>Promise<string>} }
+type SesameTestIfc = { 
+    test: { 
+        checkCandy: ()=>Promise<string>
+        subscribe: (callback) => Promise<SubscriptionResponse<{ topic: string; }>>
+    } 
+}
 
 describe('Sesame should unlock the socket', () => {
     let candy = "OK"
     let client: RPCSocket & SesameTestIfc
-    let server: RPCServer<{topic: string}, SesameTestIfc> 
+    let server: RPCServer 
+    let cb = (...args) => {}
 
     before(async() => {
-        server = new RPCServer<{ topic: string }, SesameTestIfc>(20004, [{
+        server = new RPCServer(20004, [{
             name: "test",
             exportRPCs: () => [
-                async function checkCandy():Promise<string> { return candy },
+                {
+                    name: 'subscribe',
+                    hook: async(callback) => {
+                        cb = callback
+                        return <SubscriptionResponse>{
+                            result: "Success",
+                            uuid: uuidv4(),
+                            topic: 'test'
+                        }
+                    }
+                },
+                async function checkCandy():Promise<string> { cb(candy); cb=()=>{}; return candy },
             ]}
         ],{
             sesame: (_sesame) => _sesame === 'sesame!' 
         server.destroy()
     })
 
+    it('should work with sesame', (done) => {
+        client.test.checkCandy().then(c => done())
+    })
+
     it('should not work without sesame', (done) => {
         const sock = new RPCSocket(20004, "localhost")
         sock.connect<SesameTestIfc>( /* no sesame */).then(async (c) => {
         })
     })
 
-    it('should work with sesame', (done) => {
-        client.test.checkCandy().then(c => done())
+    it('callback should work with sesame', (done) => {
+        client.test.subscribe((c) => {
+            if(c === candy){
+                done()
+            }
+        }).then(d => {
+            if(d.result !== 'Success')
+                done('expected valid response')
+
+            client.test.checkCandy()
+        })
+    })
+
+    it('callback should not work without sesame', (done) => {
+        const sock = new RPCSocket(20004, "localhost")
+        sock.connect<SesameTestIfc>( /* no sesame */).then(async (c) => {
+            c.test.subscribe((c) => {
+                console.log("CALLBACK TRIGGERED UNEXPECTED");
+                
+                if(c === candy)
+                    done("super not")
+            }).then(async d => {
+                await client.test.checkCandy()
+                if(d == null){
+                    done()
+                }else
+                    done('unexpected valid response '+(d) )
+                c.destroy()
+            })
+        })
     })
-})
+})