clean up RPC structure

Index.ts

 import * as Types from './src/Types'; 
 import * as Utils from './src/Utils'; 
 import * as Interfaces from './src/Interfaces';
-import * as Responses from './src/Responses';
 
 export {
     Back as Backend,
     Types, 
     Utils, 
     Interfaces,
-    Responses
 }

src/Backend.ts

 import * as U from './Utils'; 
 import * as I from './Interfaces';
 
-export class RPCServer{
+export class RPCServer<
+    SubResType = {}
+>{
     private ws = http.createServer()
     private io = bsock.createServer()
     private visibility:T.Visibility
 
     constructor(
         private port:number,
-        private exporters: I.Exporter[] = [],
+        private exporters: I.Exporter<SubResType>[] = [],
         conf: T.SocketConf =  {}
     ){
         

src/Frontend.ts

         const argParams = fnArgs.map(stripAfterEquals).join(",")
         return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
                             const r = await this.socket.call("`+fnName+`", `+argParams+`)
-                            if(r.uid != null){
-                                this.socket.hook(r.uid, callback)
+                            if(r.result === 'Success'){
+                                this.socket.hook(r.uuid, callback)
                             }
                             return r
                         } )()` )

src/Interfaces.ts

 import * as T from "./Types";
 import * as I from "./Interfaces"
 
-export interface Exporter{
+export interface Exporter<T = {}>{
     name: T.Name
-    exportRPCs() : T.RPC[]
+    exportRPCs() : T.RPC<T>[]
 }
 
 export interface Socket {

src/Responses.ts

-
-export type Outcome = "Success" | "Error"
-
-export class Response{
-    constructor(
-        public message?:string
-    ){}
-}
-
-export class SuccessResponse extends Response{
-    result:Outcome = "Success"
-
-    constructor(
-        message?:string
-    ){
-        super(message)
-    }
-}
-
-export class ErrorResponse extends Response{
-    result:Outcome = "Error"
-
-    constructor(
-        message: string = "Unknown error"
-    ){
-        super(message)
-    } 
-}
-
-export class SubscriptionResponse extends SuccessResponse{
-    constructor(
-        public uid: string,
-        message?:string
-    ){
-        super(message)
-    }
-}

src/Types.ts

-import * as R from "./Responses";
 import * as I from "./Interfaces";
 
 export type Visibility = "127.0.0.1" | "0.0.0.0"
     visibility?: Visibility
 }
 
+export type ResponseType = "Subscribe" | "Success" | "Error"
+export type Outcome = "Success" | "Error"
+
+
+export type Respose<T> = T & { result: Outcome }
+export type SuccessResponse<T = {}> = Respose<T> & { result: "Success" } 
+export type ErrorResponse<T = {}> = Respose<T> & { result: "Error" }
+export type SubscriptionResponse<T = {}> = Respose<T> & { result: "Success"; uuid: string }
+
 export type RPCType = 'Hook' | 'Unhook' | 'Call'
 
-export type HookRPC = {
+export type HookRPC<T = {}> = {
     name: Name
-    hook: HookFunction
+    hook: HookFunction<T>
     onCallback?: CallbackFunction,
-    onClose?: HookCloseFunction
+    onClose?: HookCloseFunction<T>
 }
 
 export type CallRPC = {
     call: AsyncFunction
 } | Function
 
-export type RPC = CallRPC | HookRPC
+export type RPC<T = {}> = CallRPC | HookRPC<T>
 
 export type BaseInfo = {
     name: Name,
     argNames: Name[],
 }
 
-export type HookInfo = BaseInfo & { 
+export type HookInfo<T = {}> = BaseInfo & { 
     type: 'Hook', 
-    generator: (socket) => HookFunction
+    generator: (socket) => HookFunction<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 = (res:R.SubscriptionResponse, rpc:HookRPC) => any
-export type HookFunction = (...args:any[]) => Promise<R.SubscriptionResponse | R.ErrorResponse>
+export type HookCloseFunction<T = {}> = (res:SubscriptionResponse<T>, rpc:HookRPC<T>) => any
+export type HookFunction<T = {}> = (...args:[any, ...any[]]) => Promise<SubscriptionResponse<T> | ErrorResponse>
 export type AsyncFunction = (...args:any[]) => Promise<any>
-export type CallbackFunction = (arg: any) => void
+export type CallbackFunction = (...args:any[]) => void

src/Utils.ts

-import * as uuid from "uuid/v4"
+import * as uuidv4 from "uuid/v4"
 
 import * as T from "./Types";
 import * as I from "./Interfaces";
+import { SubscriptionResponse } from "./Types";
 
-export const rpcToRpcinfo = (rpc : T.RPC, owner: T.Owner):T.RpcInfo => {
+export const rpcToRpcinfo = <SubResT = {}>(rpc : T.RPC<SubResT>, owner: T.Owner):T.RpcInfo => {
     switch (typeof rpc){
         case  "object":
             if(rpc['call']){
                     call: rpc['call'],
                 }
             }else{
-                const generator = hookGenerator(<T.HookRPC>rpc)
+                const generator = hookGenerator(<T.HookRPC<any>>rpc)
                 return {
                     owner: owner,
                     argNames: extractArgs(generator(undefined)),
             }
         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`)
+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),
+                type: "Call",
+                name: rpc.name,
                 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[]{
+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?"-"+uuid().substr(0,4):""
+    const suffix = makeUnique?"-"+uuidv4().substr(0,4):""
     return RPCs.map(rpc => rpcToRpcinfo(rpc, owner))
     .map(info => {
         const ret:any = info
     })
 }
 
-const hookGenerator = (rpc:T.HookRPC): T.HookInfo['generator'] => { 
+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.uid, ...cbargs])
+            socket.call.apply(socket, [res.uuid, ...cbargs])
         })
-        if(res.result == 'Success'){
+        if(res.result === 'Success'){
             if(rpc.onClose){
                 socket.on('close', async () => {
                     rpc.onClose(res, rpc)
 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(),
+    }
 }

test/TestBackend.ts

 import { RPCServer } from '../src/Backend'
-import { SubscriptionResponse, ErrorResponse, SuccessResponse } from '../src/Responses'
+import { SubscriptionResponse, ErrorResponse, SuccessResponse } from '../src/Types'
 import { HookRPC } from '../src/Types'
+import * as uuidv4 from "uuid/v4"
+import { makeSubResponse } from '../src/Utils'
 
 let subcallback
 
             name: 'simpleSubscribe',
             hook: async(callback) => {
                 subcallback =  callback
-                return new SubscriptionResponse(""+Math.random())
+                return makeSubResponse()
             }
         },{
             name: 'subscribe',
             hook: async (callback):Promise<any> => {
                 subcallback = callback
-                return new SubscriptionResponse(""+Math.random())
+                return makeSubResponse()
             },
             onClose: (res:SubscriptionResponse, rpc:HookRPC) => { 
                 console.log("Specific close handler for", rpc.name, res)
                 subcallback = null 
             },
-            onCallback: (...args) => { console.log.apply(console, args) }
+            onCallback: (...args:any) => { console.log.apply(console, args) }
+        },
+        function add(...args:number[]):number {return args.reduce((a,b)=>a+b, 0)},
+        function triggerCallback(...messages:any[]):number {return subcallback.apply({}, messages)},
+    ]
+}])
+
+new RPCServer<{ topic: string}>(20001, [{
+    name: "HelloWorldRPCGroup",
+    exportRPCs: () => [
+        {
+            name: 'echo',
+            call: async (s:string) => s,
+        },{
+            name: 'simpleSubscribe',
+            hook: async(callback) => {
+                subcallback =  callback
+                return {
+                    result: "Success",
+                    uuid: uuidv4(),
+                    topic: ""
+                }
+            }
+        },{
+            name: 'subscribe',
+            hook: async (callback) => {
+                subcallback = callback
+                return {
+                    result: "Success",
+                    uuid: uuidv4(),
+                    topic: ""
+                }
+            },
+            onClose: (res, rpc) => { 
+                console.log("Specific close handler for", rpc.name, res)
+                subcallback = null 
+            },
+            onCallback: (...args:any) => { console.log.apply(console, args) }
         },
         function add(...args:number[]):number {return args.reduce((a,b)=>a+b, 0)},
         function triggerCallback(...messages:any[]):number {return subcallback.apply({}, messages)},