setExporters

package.json

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

src/Backend.ts

 import * as T from './Types'; 
 import * as U from './Utils'; 
 import * as I from './Interfaces';
+import { Socket } from 'dgram';
+
+type Exporters<InterfaceT extends T.RPCInterface = T.RPCInterface, SubResType = {}> = I.RPCExporter<T.RPCInterface<InterfaceT>, keyof InterfaceT, SubResType>[]
 
 /**
  * A Websocket-server-on-steroids with built-in RPC capabilities
      */
     constructor(
         private port:number,
-        private exporters: I.RPCExporter<T.RPCInterface<InterfaceT>, keyof InterfaceT, SubResType>[] = [],
+        private exporters: Exporters<InterfaceT, SubResType> = [],
         conf: T.ServerConf =  {}
     ){
-        
         if(!conf.visibility) this.visibility = "127.0.0.1"        
         
         if(conf.sesame){
         ]
     }
 
+    /**
+     * Publishes a new list of Exporters. This destroys and restarts the socket
+     * @param exporters the exporters to publish
+     */
+    public setExporters(exporters: Exporters<InterfaceT, SubResType>):any{
+        exporters.forEach(U.fixNames)
+        this.destroy()
+        this.ws = http.createServer()
+        this.io = bsock.createServer()
+        this.exporters = exporters
+        this.startWebsocket()
+    }
+
     destroy(): void {
         this.io.close()
         this.ws.close()

test/Test.ts

 
 describe("Class binding", ()=>{
 
+    let exporter1 : MyExporter
+    let serv : RPCServer
+    let sock: RPCSocket & myExporterIfc
+
     class MyExporter implements RPCExporter<myExporterIfc>{
         name = "MyExporter" as "MyExporter";
         exportRPCs = () => [
             this.myRPC
         ]
 
-        myRPC = async () => "Hello World"
+        myRPC = async () => {
+            serv.setExporters([new MyOtherExporter])
+            return "Hello World"
+        }
+    }
+
+    class MyOtherExporter implements RPCExporter<myExporterIfc>{
+        name = "MyExporter" as "MyExporter";
+        exportRPCs = () => [
+            this.myRPC
+        ]
+
+        myRPC = async () => "Hello Borld"
 
     }
-    let serv: RPCServer,
-        sock: RPCSocket & myExporterIfc,
-        exporter: MyExporter
+
+    before(done => {
+        exporter1 = new MyExporter()
+        serv = new RPCServer(21004, [exporter1])
+        done()
+    })
+        
+    beforeEach((done)=>{
         
-    before((done)=>{
-        exporter = new MyExporter()
-        serv = new RPCServer(21004, [exporter])
         const s = new RPCSocket(21004, 'localhost')
         s.connect<myExporterIfc>().then(conn => {
             sock = conn
             done()
         })
     })
-    after(() => {
+
+    afterEach(done => {
         sock.destroy()
+        done()
+    })
+
+    after(() => {
         serv.destroy()
     })
 
     it("binds correctly", (done)=>{
-        sock['MyExporter'].myRPC().then(() => {
+        sock['MyExporter'].myRPC().then((res) => {
+            done(new Error(res))
+        }).catch(e => {
+            //job will time out because of setExporters
             done()
         })
     })
+
+    it("changes exporters", (done) => {
+        sock['MyExporter'].myRPC().then((res) => {
+            if(res === "Hello Borld")
+                done()
+            else
+                done(new Error(res))
+        })
+    })
 })