add timeout parameter to client socket

src/Backend.ts

 import * as T from './Types';
 import * as U from './Utils';
 import * as I from './Interfaces';
+import { BAD_CONFIG_PARAM, UNKNOWN_RPC_IDENTIFIER, UNKNOWN_RPC_SERVER } from './Strings';
 
 export class RPCServer<
     InterfaceT extends T.RPCInterface = T.RPCInterface,
             if (conf.errorHandler) conf.errorHandler(socket, error, rpcName, args)
             else {
                 if (forward) {
-                    socket.call("$UNKNOWNRPC$", error)
+                    socket.call(UNKNOWN_RPC_IDENTIFIER, error)
                 } else {
                     throw error
                 }
             this.attach(undefined, options)
         } else {
             if (options)
-                console.warn("RPCServer options were passed to listen(..) after attach(..) was called. Please pass them to attach(..) instead. Ignoring.")
+                console.warn(BAD_CONFIG_PARAM)
         }
         this.pio.listen(port)
         return this
                 clientSocket.on("*", (packet) => {
                     if (!infos.some(i => i.uniqueName === packet.data[0])) {
                         if (packet.data[0].startsWith('destroy_')) return
-                        this.errorHandler(clientSocket, new Error(`Unknown RPC ${packet.data[0]}`), packet.data[0], [...packet.data].splice(1), true)
+                        this.errorHandler(clientSocket, new Error(UNKNOWN_RPC_SERVER(packet.data[0])), packet.data[0], [...packet.data].splice(1), true)
                     }
                 })
             }

src/Frontend.ts

 import * as T from './Types';
 import * as I from './Interfaces';
 import { stripAfterEquals, appendComma } from './Utils';
+import { SOCKET_NOT_CONNECTED, UNKNOWN_RPC_IDENTIFIER, USER_DEFINED_TIMEOUT } from './Strings';
 
 
 /**
      */
     constructor(public port: number, public address: string, private conf: T.ClientConfig = defaultClientConfig) {
         Object.defineProperty(this, 'socket', { value: undefined, writable: true })
-        this.hook("$UNKNOWNRPC$", (err) => this.handlers['error'].forEach(handler => handler(err)))
+        this.hook(UNKNOWN_RPC_IDENTIFIER, (err) => this.handlers['error'].forEach(handler => handler(err)))
     }
 
     /**
      * @param args other arguments
      */
     public async call(rpcname: string, ...args: any[]): Promise<any> {
-        if (!this.socket) throw new Error("The socket is not connected! Use socket.connect() first")
+        if (!this.socket) throw new Error(SOCKET_NOT_CONNECTED)
+
 
         try {
-            const val = await this.socket.call.apply(this.socket, [rpcname, ...args])
-            return val
+            if(!this.conf.callTimeoutMs || this.conf.callTimeoutMs <= 0)
+                return await this.socket.call.apply(this.socket, [rpcname, ...args])
+            else 
+                return await Promise.race([
+                    this.socket.call.apply(this.socket, [rpcname, ...args]),
+                    new Promise((_, rej) => {
+                        setTimeout(_ => rej(USER_DEFINED_TIMEOUT(this.conf.callTimeoutMs)), this.conf.callTimeoutMs)
+                    }) 
+                ])
         } catch (e) {
             this.emit('error', e)
             throw e
      * @param args other arguments
      */
     public async fire(rpcname: string, ...args: any[]): Promise<void> {
-        if (!this.socket) throw new Error("The socket is not connected! Use socket.connect() first")
+        if (!this.socket) throw new Error(SOCKET_NOT_CONNECTED)
         await this.socket.fire.apply(this.socket, [rpcname, ...args])
     }
 
      * Get a list of available RPCs from the server
      */
     public async info(sesame?: string) {
-        if (!this.socket) throw new Error("The socket is not connected! Use socket.connect() first")
+        if (!this.socket) throw new Error(SOCKET_NOT_CONNECTED)
         return await this.socket.call('info', sesame)
     }
 

src/Interfaces.ts

 import * as T from "./Types";
-import * as I from "./Interfaces"
 
 /**
  * Interface for all classes that export RPCs

src/PromiseIO/Client.ts

     reconnectionDelay: 200,
     timeout: 450,
     reconnection: false,
+    callTimeoutMs: 0,
 } 
 
 export class PromiseIOClient {

src/Strings.ts

+export const USER_DEFINED_TIMEOUT = ms => `User defined socket timout after ${ms}ms`
+export const SOCKET_NOT_CONNECTED = "The socket is not connected! Use socket.connect() first"
+export const UNKNOWN_RPC_IDENTIFIER = "$UNKNOWNRPC$"
+export const UNKNOWN_RPC_SERVER = name => `Unknown RPC ${name}`
+export const RPC_BAD_TYPE = type => `Bad socketIORPC type ${type}`
+export const CALL_NOT_FOUND = callName => `Call not found: ${callName}. ; Zone: <root> ; Task: Promise.then ; Value: Error: Call not found: ${callName}`
+export const BAD_CONFIG_PARAM = "RPCServer options were passed to listen(..) after attach(..) was called. Please pass them to attach(..) instead. Ignoring."
+export const RPC_NO_NAME = name => `
+RPC did not provide a name. 
+\nUse 'funtion name(..){ .. }' syntax instead.
+\n
+\n<------------OFFENDING RPC:
+\n${name}
+\n>------------OFFENDING RPC`

src/Types.ts

     'close' : () => void
 }
 export type ClientConfig = SocketIOClient.ConnectOpts & {
-    protocol?: 'http' | 'https'
+    protocol?: 'http' | 'https',
+    callTimeoutMs?: number
 }
 export type ExporterArray<InterfaceT extends RPCInterface = RPCInterface> = I.RPCExporter<RPCInterface<InterfaceT>, keyof InterfaceT>[]
 

src/Utils.ts

 import * as T from "./Types";
 import * as I from "./Interfaces";
 import { Socket } from "socket.io"
+import { CALL_NOT_FOUND, RPC_BAD_TYPE, RPC_NO_NAME } from "./Strings";
 
 /**
  * Translate an RPC to RPCInfo for serialization.
                 }
             }
         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`)
+            if (!rpc.name) throw new Error(RPC_NO_NAME(rpc.toString()))
             return {
                 owner: owner,
                 argNames: extractArgs(rpc),
                 call: sesame ? async ($__sesame__$, ...args) => { if (sesame($__sesame__$)) return await rpc.apply({}, args); throw makeError(rpc.name) } : rpc, // check & remove sesame 
             }
     }
-    throw new Error("Bad socketIORPC type " + typeof rpc)
+    throw new Error(RPC_BAD_TYPE(typeof rpc))
 }
 
 /**
     return eval(hookStr)
 }
 
-const makeError = (callName: string) => new Error(`Call not found: ${callName}. ; Zone: <root> ; Task: Promise.then ; Value: Error: Call not found: ${callName}`)
+const makeError = (callName: string) => new Error(CALL_NOT_FOUND(callName))
 
 /**
  * Extract a string list of parameters from a function

test/Test.ts

 import { PromiseIO } from "../src/PromiseIO/Server";
 import { PromiseIOClient } from "../src/PromiseIO/Client";
 import { assert, expect } from 'chai';
+import { USER_DEFINED_TIMEOUT } from "../src/Strings";
 var should = require('chai').should();
-
+var chai = require("chai");
+var chaiAsPromised = require("chai-as-promised");
+ 
+chai.use(chaiAsPromised);
 const noop = (...args) => { }
 
 const add = (...args: number[]) => { return args.reduce((a, b) => a + b, 0) }
             ],
         }
     ]
+    const callTimeout = 100;
 
     let client: RPCSocket, client2: RPCSocket, server: RPCServer, server2: RPCServer
 
 
         new RPCSocket(8080, 'localhost').connect().then(sock => {
             client = sock
-            new RPCSocket(8080, 'localhost', { path: "test" }).connect().then(sock2 => {
+            new RPCSocket(8080, 'localhost', { path: "test", callTimeoutMs: callTimeout }).connect().then(sock2 => {
                 client2 = sock2
                 done()
             })
         const res2 = await client2['Grp2'].test()
         expect(res2).to.equal('/test')
     })
+
+    it('server1 should answer after server2 is closed', async () => {
+        server2.close()
+        const res = await client['HelloWorldRPCGroup'].echo("test")
+        expect(res).to.equal('test')
+        return client2['Grp2'].test().should.eventually.be.rejectedWith(USER_DEFINED_TIMEOUT(callTimeout))
+    })
 })
 
 describe("can attach second RPCServer if first is already running", () => {