rpclibrary/src/Utils.ts

import * as uuid from "uuid/v4"

import * as T from "./Types";
import * as I from "./Interfaces";

export const rpcToRpcinfo = (rpc : T.RPC, owner: T.Owner):T.RpcInfo => {
    switch (typeof rpc){
        case  "object":
        switch(rpc.type){
            case "Call" :
                return {
                    owner: owner,
                    argNames: extractArgs(rpc.call),
                    type: rpc.type,
                    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 {
                    owner: owner,
                    argNames: extractArgs(generator(undefined)),
                    type: rpc.type,
                    name: rpc.name,
                    unhook: rpc.unhook,
                    generator: generator,
                }
        }
        break;
        case "function":
            if(!rpc.name) throw new Error(`
            RPC did not provide a name. 
            \nUse funtion name(..){ .. } syntax instead.
            \n
            \n<------------OFFENDING RPC:
            \n`+rpc.toString()+`
            \n>------------OFFENDING RPC`)
            return {
                type: "Call",
                owner : owner,
                argNames: extractArgs(rpc),
                call: async(...args) => rpc.apply({}, args),
                name: rpc.name
            }
    }
    throw new Error("Bad socketIORPC type "+ typeof rpc)
}

export function rpcHooker(socket: I.Socket, exporter:I.Exporter, makeUnique = true):T.ExtendedRpcInfo[]{
    const owner = exporter.name
    const RPCs = [...exporter.exportRPCs()]
    const suffix = makeUnique?"-"+uuid().substr(0,4):""
    return RPCs.map(rpc => rpcToRpcinfo(rpc, owner))
    .map(info => {
        const ret:any = info
        ret.uniqueName = info.name+suffix

        switch(info.type){
            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;
        }
        socket.on('close', () => socket.unhook(info.name))
        return ret
    })
}

const hookGenerator = (rpc:T.HookRPC): T.HookInfo['generator'] => { 
    const argsArr = extractArgs(rpc.hook)
    argsArr.pop()
    const args = argsArr.join(',')

    return eval(`(socket) => async (`+args+`) => { 
        const res = await rpc.hook(`+args+(args.length!==0?',':'')+` (x) => {
            socket.call(res.uid, x)
        })
        if(res.result == 'Success'){
            socket.on('close', async () => {
                const unhookRes = await rpc.unhook(res.uid)
                console.log("Specific close handler for", rpc.name, res.uid, unhookRes)
            })
        }
        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
}