test123

src/Backend.ts

  * A Websocket-server-on-steroids with built-in RPC capabilities
  */
 export class RPCServer<
-    SubResType = {}
+    SubResType = {},
+    InterfaceT extends T.RPCInterface = T.RPCInterface,
 > implements I.Destroyable{
-        
     private ws = http.createServer()
     private io = bsock.createServer()
     private visibility:T.Visibility
      */
     constructor(
         private port:number,
-        private exporters: I.RPCExporter<SubResType>[] = [],
+        private exporters: I.RPCExporter<T.RPCInterface<InterfaceT>, keyof T.RPCInterface<InterfaceT>, SubResType>[] = [],
         conf: T.SocketConf =  {}
     ){
         

src/Frontend.ts

  * A websocket-on-steroids with built-in RPC capabilities
  */
 export class RPCSocket implements I.Socket{
+    static async makeSocket<T extends T.RPCInterface= T.RPCInterface>(port:number, server: string, tls: boolean = false): Promise<RPCSocket & T.RPCInterface<T>> {
+        const socket = <RPCSocket & T> new RPCSocket(port, server, tls)
+        return await socket.connect<T>()
+    }
+
     private socket: I.Socket
 
     /**
      * @param name The function name to listen on
      * @param handler The handler to attach
      */
-    public hook(name: T.Name, handler: (...args:any[]) => any | Promise<any>){
+    public hook(name: string, handler: (...args:any[]) => any | Promise<any>){
         return this.socket.hook(name, handler)
     }
 
      * Removes a {@link hook} listener by name.
      * @param name The function name 
      */
-    public unhook(name: T.Name){
+    public unhook(name: string){
         return this.socket.unhook(name)
     }
 
      * @param rpcname The function to call
      * @param args other arguments
      */
-    public async call (rpcname: T.Name, ...args: T.Any[]) : Promise<T.Any>{
+    public async call (rpcname: string, ...args: any[]) : Promise<any>{
         return await this.socket.call.apply(this.socket, [rpcname, ...args])
     }
 
      * @param rpcname The function to call
      * @param args other arguments
      */
-    public async fire(rpcname: T.Name, ...args: T.Any[]) : Promise<void>{
+    public async fire(rpcname: string, ...args: any[]) : Promise<void>{
         await this.socket.fire.apply(this.socket, [rpcname, ...args])
     }
     
     /**
      * Connects to the server and attaches available RPCs to this object
      */
-    public async connect(){
+    public async connect<T extends T.RPCInterface= T.RPCInterface>() : Promise<RPCSocket & T.RPCInterface<T>>{
         this.socket = await bsock.connect(this.port, this.server, this.tls)
 
         const info:T.ExtendedRpcInfo[] = await this.info()
             this[i.owner][i.name] = f
             this[i.owner][i.name].bind(this)
         })
+        return <RPCSocket & T.RPCInterface<T>> <any> this
     }
 
     /**
      * @param fnName The function name
      * @param fnArgs A string-list of parameters
      */
-    private callGenerator(fnName: T.Name, fnArgs:T.Arg[]): T.AsyncFunction{
+    private callGenerator(fnName: string, fnArgs:string[]): T.AsyncFunction{
         const headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
         return eval( '( () => async ('+headerArgs+') => { return await this.socket.call("'+fnName+'", '+argParams+')} )()' )
      * @param fnName The function name
      * @param fnArgs A string-list of parameters
      */
-    private hookGenerator(fnName: T.Name, fnArgs:T.Arg[]): T.HookFunction{
+    private hookGenerator(fnName: string, fnArgs:string[]): T.HookFunction{
         const headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
         return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {

src/Interfaces.ts

 /**
  * Interface for all classes that may export RPCs
  */
-export interface RPCExporter<T = {}>{
-    name: T.Name
-    exportRPCs() : T.RPC<T>[]
+export interface RPCExporter<
+    Ifc extends T.RPCInterface, 
+    K extends keyof Ifc, 
+    SubresT = {}
+>{
+    name: K
+    exportRPCs() : T.RPC<Ifc[K], keyof Ifc[K], SubresT>[]
 }
 
 /**
  */
 export interface Socket extends Destroyable {
     port: number
-    hook: (rpcname: T.Name, handler: (...args:any[]) => any | Promise<any>) => I.Socket
-    unhook: (rpcname:T.Name) => I.Socket
-    call: (rpcname:T.Name, ...args: T.Any[]) => Promise<T.Any>
-    fire: (rpcname:T.Name, ...args: T.Any[]) => Promise<T.Any>
+    hook: (rpcname: string, handler: T.AnyFunction) => I.Socket
+    unhook: (rpcname:string) => I.Socket
+    call: (rpcname:string, ...args: any[]) => Promise<any>
+    fire: (rpcname:string, ...args: any[]) => Promise<any>
     on: T.OnFunction    
     close() : void
 }

src/Types.ts

 import * as I from "./Interfaces";
 
+export type AnyFunction = (...any:any)=>any
+export type AsyncFunction<Fn extends AnyFunction = AnyFunction> = ReturnType<Fn> extends Promise<any> ? Fn : (...any:Parameters<Fn>) => Promise<ReturnType<Fn>>
+export type RPCGroup = { [name in string] : AsyncFunction }
+export type RPCInterface<Impl extends RPCInterface = {}> = { [groupName in string]: RPCGroup } & Impl
+
 export type Visibility = "127.0.0.1" | "0.0.0.0"
-export type Any = any
-export type Arg = string
-export type Name = Arg
-export type Owner = Name
 export type ConnectionHandler = (socket:I.Socket) => void
 export type ErrorHandler = (socket:I.Socket, error:any) => void
 export type CloseHandler = (socket:I.Socket) =>  void
 
 export type RPCType = 'Hook' | 'Unhook' | 'Call'
 
-export type HookRPC<T = {}> = {
-    name: Name
-    hook: HookFunction<T>
+export type HookT<G extends RPCGroup, K extends keyof G, SubresT> = AsyncFunction<HookFunction<G[K], SubresT>>
+export type CallT<G extends RPCGroup, K extends keyof G> = AsyncFunction<G[K]>
+
+export type HookRPC<G extends RPCGroup, K extends keyof G, SubresT = {}> = {
+    name: K
+    hook: HookT<G, K, SubresT>
     onCallback?: CallbackFunction,
-    onClose?: HookCloseFunction<T>
+    onClose?: HookCloseFunction<SubresT>
 }
 
-export type CallRPC = {
-    name: Name
-    call: AsyncFunction
-} | Function
+export type CallRPC<G extends RPCGroup, K extends keyof G> = {
+    name: K
+    call: CallT<G,K>
+} 
 
-export type RPC<T = {}> = CallRPC | HookRPC<T>
+export type RPC<G extends RPCGroup, Kg extends keyof G, SubresT> = CallRPC<G, Kg> | HookRPC<G, Kg, SubresT>
 
 export type BaseInfo = {
-    name: Name,
-    owner: Name,
-    argNames: Name[],
+    name: string,
+    owner: string,
+    argNames: string[],
 }
 
 export type HookInfo<T = {}> = BaseInfo & { 
     type: 'Hook', 
-    generator: (socket?:I.Socket) => HookFunction<T>
+    generator: (socket?:I.Socket) => HookFunction<AnyFunction, T>
 }
 
 export type CallInfo = BaseInfo & {
 export type ExtendedRpcInfo = RpcInfo & { uniqueName: string } 
 
 export type OnFunction = (type: 'error' | 'close', f: (e?:any)=>void) => I.Socket
-export type HookCloseFunction<T = {}> = (res:SubscriptionResponse<T>, rpc:HookRPC<T>) => any
-export type HookFunction<T = {}> = (...args:any) => Promise<SubscriptionResponse<T> | ErrorResponse>
-export type AsyncFunction = (...args:any) => Promise<any>
-export type CallbackFunction = (...args:any) => void
+export type HookCloseFunction<T = {}> = (res:SubscriptionResponse<T>, rpc:HookRPC<any, any, T>) => any
+export type HookFunction<F extends AnyFunction = AnyFunction, SubResT = {}> = AsyncFunction<(...args:Parameters<F>) => SubscriptionResponse<SubResT> | ErrorResponse>
+export type CallbackFunction = (callback:AnyFunction, ...args:any) => any

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<SubResT>, owner: T.Owner):T.RpcInfo => {
+export const rpcToRpcinfo = <SubResT = {}>(rpc : T.RPC<any, any, SubResT>, owner: string):T.RpcInfo => {
     switch (typeof rpc){
         case  "object":
             if(rpc['call']){
                     call: rpc['call'],
                 }
             }else{
-                const generator = hookGenerator(<T.HookRPC<any>>rpc)
+                const generator = hookGenerator(<T.HookRPC<any, any, any>>rpc)
                 return {
                     owner: owner,
                     argNames: extractArgs(generator(undefined)),
                 argNames: extractArgs(rpc),
                 type: "Call",
                 name: rpc.name,
-                call: async(...args) => rpc.apply({}, args),
+                call: async(...args) => (<Function>rpc).apply({}, args),
             }
     }
     throw new Error("Bad socketIORPC type "+ typeof rpc)
  * @param exporter The exporter
  * @param makeUnique @default true Attach a suffix to RPC names
  */
-export function rpcHooker<SubResT = {}>(socket: I.Socket, exporter:I.RPCExporter<SubResT>, makeUnique = true):T.ExtendedRpcInfo[]{
+export function rpcHooker<SubResT = {}>(socket: I.Socket, exporter:I.RPCExporter<any, any, SubResT>, makeUnique = true):T.ExtendedRpcInfo[]{
     const owner = exporter.name
     const RPCs = [...exporter.exportRPCs()]
     const suffix = makeUnique?"-"+uuidv4().substr(0,4):""
  * @param rpc The RPC to transform
  * @returns A {@link HookFunction}
  */
-const hookGenerator = (rpc:T.HookRPC<any>): T.HookInfo['generator'] => { 
+const hookGenerator = (rpc:T.HookRPC<any, any, any>): T.HookInfo['generator'] => { 
     const argsArr = extractArgs(rpc.hook)
     argsArr.pop()
     const args = argsArr.join(',')
  * Extract a string list of parameters from a function
  * @param f The source function
  */
-const extractArgs = (f:Function):T.Arg[] => {
-    let fn
+const extractArgs = (f:Function):string[] => {
+    let fn:string
     return (fn = String(f)).substr(0, fn.indexOf(")")).substr(fn.indexOf("(")+1).split(",")
 }
 

test/Test.ts

 
 
 describe('RPCServer', () => {
-    let server: RPCServer<{ topic: string}>
+    let server: RPCServer<{ topic: string }, any>
 
     before((done) => {
         server = makeServer()
             name: "test",
             exportRPCs: () => [{
                 name: 'subscribe',
-                hook: async(callback) => {
-                    cb = callback
+                hook: async(callback):Promise<SubscriptionResponse<{topic:string}>> => {
+                    cb = <Function> callback
                     return {
                         result: "Success",
                         uuid: uuidv4(),

test/devtest.ts

+import { RPCServer } from "../src/Backend";
+import { SubscriptionResponse, CallRPC, HookRPC, RPCInterface } from "../src/Types";
+import { RPCSocket } from "../src/Frontend";
+
+type MyInterface = RPCInterface<{ 
+    Group1: { 
+        triggerCallbacks: (...args:any[]) => Promise<void>,
+        subscribe: (param:string, callback:Function) => Promise<SubscriptionResponse<{a: string}>>,
+        unsubscribe: (uuid:string) => Promise<void>
+    },
+    Group2: {
+        echo: (x:string) => Promise<string>
+    }
+}>
+
+const callbacks:Map<string, Function> = new Map()
+
+new RPCServer<{a:string}, MyInterface>(20000, 
+    [{
+        name: "Group1",
+        exportRPCs: () => [
+        <HookRPC<MyInterface['Group1'], 'subscribe', {a:string}>>{
+            name: 'subscribe',
+            hook: async (param, callback) => { const _uuid = ""+Math.random(); console.log(param); callbacks.set(_uuid, callback); return { result: 'Success', a: '3', uuid: _uuid} }
+        },
+        <CallRPC<MyInterface['Group1'], 'unsubscribe'>>{
+            name: 'unsubscribe',
+            call: async (uuid) => { callbacks.delete(uuid) }
+        },
+        <CallRPC<MyInterface['Group1'], 'triggerCallbacks'>>{
+            name: 'triggerCallbacks',
+            call: async (...args) => { callbacks.forEach(cb => cb.apply({}, args)) }
+        }]
+    },{
+        name: 'Group2',
+        exportRPCs: () => [
+        <CallRPC<MyInterface['Group2'], 'echo'>>{
+            name: 'echo',
+            call: async (x) => x
+        }]
+    }]
+)
+
+new RPCServer<{a:string}, MyInterface>(20001, 
+    [{
+        name: "Group1",
+        exportRPCs: () => []
+    },{
+        name: 'Group2',
+        exportRPCs: () => [{
+            name: 'echo',
+            call: async (x) => x+" lol"
+        }]
+    }]
+)
+
+RPCSocket.makeSocket<MyInterface>(20000, 'localhost').then((async (client) => {
+    console.log(client)
+    const res = await client.Group1.subscribe('test', async (...args:any) => {
+        console.log.apply(console, args)
+
+        /* close the callbacks once you're done */
+        await client.Group1.unsubscribe(res.uuid)
+        client.unhook(res.uuid)
+    })
+
+    await client.Group1.triggerCallbacks("Hello", "World", "Callbacks")
+}))
+
+RPCSocket.makeSocket<MyInterface>(20001, 'localhost').then((async (client) => {
+    console.log(client)
+    const r = await client.Group2.echo("hee")
+    console.log(r)
+}))