rpclibrary/src/Backend.ts

'use strict'

import http = require('http');
import bsock = require('bsock');

import * as T from './Types'; 
import * as U from './Utils'; 
import * as I from './Interfaces';

export class RPCServer<
    SubResType = {}
> implements I.Destroyable{
        
    private ws = http.createServer()
    private io = bsock.createServer()
    private visibility:T.Visibility
    private closeHandler:T.CloseHandler
    private errorHandler: T.ErrorHandler
    private connectionHandler: T.ConnectionHandler


    constructor(
        private port:number,
        private exporters: I.Exporter<SubResType>[] = [],
        conf: T.SocketConf =  {}
    ){
        
        if(!conf.visibility) this.visibility = "127.0.0.1"        
        
        if(!conf.errorHandler) this.errorHandler = 
        (socket:I.Socket) => (error:any) => { 
            socket.destroy(); 
            console.error("Caught websocket error", String(error)) 
        }
        
        if(!conf.closeHandler) this.closeHandler = 
        (socket:I.Socket) => () => { 
            console.log("Socket on port "+socket.port+" closing") 
        }
        
        if(!conf.connectionHandler) this.connectionHandler = 
        (socket:I.Socket) => { 
            console.log("New websocket connection on port "+socket.port)
        }

        let badRPC 
        if(badRPC = exporters.flatMap(ex => ex.exportRPCs()).find(rpc => !rpc.name))
        throw new Error(`
            RPC did not provide a name. 
            \nUse 'funtion name(..){ .. }' syntax instead.
            \n
            \n<------------OFFENDING RPC:
            \n`+badRPC.toString()+`
            \n>------------OFFENDING RPC`)

        this.startWebsocket()
    }

    private startWebsocket(){
        try{
            this.io.attach(this.ws)
            this.io.on('socket', (socket:I.Socket) => {
                socket.on('error', this.errorHandler(socket))
                socket.on('close', this.closeHandler(socket))
                this.connectionHandler(socket)
                this.initRPCs(socket)
            })
            this.ws.listen(this.port, this.visibility)
        }catch(e){
            //@ts-ignore
            this.errorHandler(undefined)("Unable to connect to socket")
        }
    }

    protected initRPCs(socket:I.Socket){
        socket.hook('info', () => rpcInfos)

        const rpcInfos:T.ExtendedRpcInfo[] = [
            ...this.exporters.flatMap(exporter => U.rpcHooker(socket, exporter))
        ]
    }

    async destroy(): Promise<void> {
        this.io.close()
        this.ws.close()
    }
}