v 1.3.0 improve pseudointerfaces

README.md

 This feature is currently still in development and considered **unstable and untested**. Use with caution.
 
 ```typescript
-type MyInterface = RPCInterface<{ 
+type MyInterface = { 
     Group1: { 
         triggerCallbacks: (...args:any[]) => Promise<void>,
         subscribe: (param:string, callback:Function) => Promise<SubscriptionResponse<{a: string}>>,
     Group2: {
         echo: (x:string) => Promise<string>
     }
-}>
+}
 ```
 Create a client using
 ```typescript

package.json

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

src/Backend.ts

      */
     constructor(
         private port:number,
-        private exporters: I.RPCExporter<T.RPCInterface<InterfaceT>, keyof T.RPCInterface<InterfaceT>, SubResType>[] = [],
+        private exporters: I.RPCExporter<T.RPCInterface<InterfaceT>, keyof InterfaceT, SubResType>[] = [],
         conf: T.SocketConf =  {}
     ){
         

src/Frontend.ts

      * @param fnName The function name
      * @param fnArgs A string-list of parameters
      */
-    private callGenerator(fnName: string, fnArgs:string[]): T.AsyncFunction{
+    private callGenerator(fnName: string, fnArgs:string[]): T.AnyFunction{
         const headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
         return eval( '( () => async ('+headerArgs+') => { return await this.socket.call("'+fnName+'", '+argParams+')} )()' )

src/Interfaces.ts

 import * as I from "./Interfaces"
 
 /**
- * Interface for all classes that may export RPCs
+ * Interface for all classes that export RPCs
  */
 export interface RPCExporter<
-    Ifc extends T.RPCInterface, 
-    K extends keyof Ifc, 
+    Ifc extends T.RPCInterface,
+    Name extends keyof Ifc,
     SubresT = {}
 >{
-    name: K
-    exportRPCs() : T.RPC<Ifc[K], keyof Ifc[K], SubresT>[]
+    name: Name
+    exportRPCs() : T.RPCInterfaceArray<Ifc, SubresT>[Name]
 }
 
 /**

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 AnyFunction = (...args:any) => any
+export type HookFunction<F extends AnyFunction = AnyFunction, SubresT = {}> = (...args: Parameters<F>) => Promise<SubscriptionResponse<SubresT> | ErrorResponse>
 
 export type Visibility = "127.0.0.1" | "0.0.0.0"
 export type ConnectionHandler = (socket:I.Socket) => void
 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", message?:string }
 
 export type RPCType = 'Hook' | 'Unhook' | 'Call'
 
-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 CallRPC<N, F> = {
+    name: N
+    call: F
+}
 
-export type HookRPC<G extends RPCGroup, K extends keyof G, SubresT = {}> = {
-    name: K
-    hook: HookT<G, K, SubresT>
-    onCallback?: CallbackFunction,
+export type HookRPC<N, F extends AnyFunction, SubresT = {}> = {
+    name: N
+    hook: HookFunction<F, SubresT>
+    onCallback?: AnyFunction
     onClose?: HookCloseFunction<SubresT>
 }
 
-export type CallRPC<G extends RPCGroup, K extends keyof G> = {
-    name: K
-    call: CallT<G,K>
-} 
+export type RPC<N, F extends AnyFunction, SubresT = {}> = HookRPC<N, F, SubresT> | CallRPC<N,F> | F
 
-export type RPC<G extends RPCGroup, Kg extends keyof G, SubresT> = CallRPC<G, Kg> | HookRPC<G, Kg, SubresT>
+export type RPCInterface<Impl extends RPCInterface = {}> = {
+    [grp in string] : {
+        [rpc in string] : AnyFunction
+    } 
+} & Impl
+
+export type RPCInterfaceArray<Itfc extends RPCInterface, SubresT = {}> = {
+    [grp in keyof Itfc]: Array<
+      { [rpc in keyof Itfc[grp]]: RPC<rpc, Itfc[grp][rpc], SubresT> }[keyof Itfc[grp]]
+    >
+}
 
 export type BaseInfo = {
     name: string,
     argNames: string[],
 }
 
-export type HookInfo<T = {}> = BaseInfo & { 
+export type HookInfo<SubresT = {}> = BaseInfo & { 
     type: 'Hook', 
-    generator: (socket?:I.Socket) => HookFunction<AnyFunction, T>
+    generator: (socket?:I.Socket) => (...args:any) => SubresT
 }
 
 export type CallInfo = BaseInfo & {
     type: 'Call',
-    call: AsyncFunction
+    call: AnyFunction
 }
 
 export type RpcInfo = HookInfo |  CallInfo
 
 export type OnFunction = (type: 'error' | 'close', f: (e?:any)=>void) => I.Socket
 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

test/Test.ts

 import * as uuidv4 from "uuid/v4"
 import { RPCSocket } from "../src/Frontend";
 import { SubscriptionResponse } from "../src/Types";
+import { makeSubResponse } from "../src/Utils";
 
 const add = (...args:number[]) => {return args.reduce((a,b)=>a+b, 0)}
 function makeServer(){
                 name: 'simpleSubscribe',
                 hook: async(callback) => {
                     subcallback =  callback
-                    return {
-                        result: "Success",
-                        uuid: uuidv4(),
-                        topic: "test"
-                    }
+                    return makeSubResponse<{topic: string}>({topic: "test"})
                 }
             },{
                 name: 'subscribe',
                 hook: async (callback) => {
                     subcallback = callback
-                    return {
-                        result: "Success",
-                        uuid: uuidv4(),
-                        topic: "test"
-                    }
+                    return makeSubResponse<{topic: string}>({topic: "test"})
                 },
                 onClose: (res, rpc) => { 
                     console.log("onClose", rpc.name === 'subscribe' && res?"OK":"")

test/devtest.ts

 import { RPCServer } from "../src/Backend";
-import { SubscriptionResponse, CallRPC, HookRPC, RPCInterface } from "../src/Types";
+import { SubscriptionResponse, RPCInterface } from "../src/Types";
 import { RPCSocket } from "../src/Frontend";
+import { makeSubResponse } from "../src/Utils";
 
-type MyInterface = RPCInterface<{ 
+type SubresExtension = {a:string}
+
+type MyInterface = { 
     Group1: { 
         triggerCallbacks: (...args:any[]) => Promise<void>,
-        subscribe: (param:string, callback:Function) => Promise<SubscriptionResponse<{a: string}>>,
+        subscribe: (param:string, callback:Function) => Promise<SubscriptionResponse<SubresExtension>>,
         unsubscribe: (uuid:string) => Promise<void>
     },
     Group2: {
         echo: (x:string) => Promise<string>
     }
-}>
-
-const callbacks:Map<string, Function> = new Map()
+}
 
-new RPCServer<{a:string}, MyInterface>(20000, 
+new RPCServer<SubresExtension, MyInterface>(20000, 
     [{
-        name: "Group1",
-        exportRPCs: () => [
-        <HookRPC<MyInterface['Group1'], 'subscribe', {a:string}>>{
+        name: 'Group1',
+        exportRPCs: () => [{
+            name: 'triggerCallbacks',
+            call: async () => { /*...*/ }
+        },{
             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'>>{
+            hook: async (param, callback) => { return makeSubResponse<SubresExtension>({a: "test"}) }
+        },{
             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: () => []
+            call: async(uuid) => { }
+        }
+    ]
     },{
         name: 'Group2',
         exportRPCs: () => [{
             name: 'echo',
-            call: async (x) => x+" lol"
+            call: async (x) => "..."
         }]
     }]
 )
     })
 
     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)
 }))