rpclibrary/src/Utils.ts

import * as uuidv4 from "uuid/v4"

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


export const rpcToRpcinfo = <SubResT = {}>(rpc : T.RPC<SubResT>, owner: T.Owner):T.RpcInfo => {
    switch (typeof rpc){
        case  "object":
            if(rpc['call']){
                return {
                    owner: owner,
                    argNames: extractArgs(rpc['call']),
                    type: "Call",
                    name: rpc.name,
                    call: rpc['call'],
                }
            }else{
                const generator = hookGenerator(<T.HookRPC<any>>rpc)
                return {
                    owner: owner,
                    argNames: extractArgs(generator(undefined)),
                    type: "Hook",
                    name: rpc.name,
                    generator: generator,
                }
            }
        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 {
                owner : owner,
                argNames: extractArgs(rpc),
                type: "Call",
                name: rpc.name,
                call: async(...args) => rpc.apply({}, args),
            }
    }
    throw new Error("Bad socketIORPC type "+ typeof rpc)
}

export function rpcHooker<SubResT = {}>(socket: I.Socket, exporter:I.Exporter<SubResT>, makeUnique = true):T.ExtendedRpcInfo[]{
    const owner = exporter.name
    const RPCs = [...exporter.exportRPCs()]
    const suffix = makeUnique?"-"+uuidv4().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 "Call":
                socket.hook(ret.uniqueName, info.call)
                break;
        }
        socket.on('close', () => socket.unhook(info.name))
        return ret
    })
}
//
const hookGenerator = (rpc:T.HookRPC<any>): 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?',':'')+` (...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
    }`)
}

const extractArgs = (f:Function):T.Arg[] => {
    let fn
    return (fn = String(f)).substr(0, fn.indexOf(")")).substr(fn.indexOf("(")+1).split(",")
}

export function makeSubResponse(uuid?:string):SubscriptionResponse{
    return {
        result: "Success",
        uuid: uuid?uuid:uuidv4(),
    }
}