rpclibrary/src/Backend.ts

'use strict'

import http = require('http');
import { PromiseIO } from "./PromiseIO/Server";
import * as T from './Types';
import * as U from './Utils';
import * as I from './Interfaces';

export class RPCServer<
    InterfaceT extends T.RPCInterface = T.RPCInterface,
    > {

    private pio = new PromiseIO()
    private closeHandler: T.CloseHandler
    private errorHandler: (socket: I.Socket, error: any, rpcName: string, args: any[], forward?: boolean) => void
    private connectionHandler: T.ConnectionHandler
    private sesame?: T.SesameFunction
    private accessFilter: T.AccessFilter<InterfaceT>
    private attached = false

    /**
     * @throws On RPC with no name
     * @param port The port to listen on
     * @param exporters A list of {@link RPCExporter} to publish
     * @param conf A {@link SocketConf} object with optional settings
     */
    constructor(
        private exporters: T.ExporterArray<InterfaceT> = [],
        private conf: T.ServerConf<InterfaceT> = {},
    ) {
        if (conf.throwOnUnknownRPC == null) {
            conf.throwOnUnknownRPC = true
        }

        if (conf.sesame) {
            this.sesame = U.makeSesameFunction(conf.sesame)
        }

        this.accessFilter = conf.accessFilter || (async (sesame) => {
            if (!this.sesame) return true
            return this.sesame!(sesame!)
        })

        this.errorHandler = (socket: I.Socket, error: any, rpcName: string, args: any[], forward: boolean = false) => {
            if (conf.errorHandler) conf.errorHandler(socket, error, rpcName, args)
            else {
                if (forward) {
                    socket.call("$UNKNOWNRPC$", error)
                } else {
                    throw error
                }
            }
        }

        this.closeHandler = (socket: I.Socket) => {
            if (conf.closeHandler) conf.closeHandler(socket)
        }

        this.connectionHandler = (socket: I.Socket) => {
            if (conf.connectionHandler) conf.connectionHandler(socket)
        }

        exporters.forEach(U.fixNames) //TSC for some reason doesn't preserve name properties of methods

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

        try {

            this.pio.on('socket', (clientSocket: I.Socket) => {
                clientSocket.on('disconnect', () => this.closeHandler(clientSocket))
                this.connectionHandler(clientSocket)
                this.initRPCs(clientSocket)
            })
        } catch (e) {
            this.errorHandler(<unknown>undefined as I.Socket, e, 'system', [])
        }
    }

    public attach = (httpServer = new http.Server(), options?: SocketIO.ServerOptions): RPCServer<InterfaceT> => {
        this.pio.attach(httpServer, options)
        this.attached = true
        return this
    }

    public listen(port: number, options?: SocketIO.ServerOptions): RPCServer<InterfaceT> {
        if (!this.attached) {
            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.")
        }
        this.pio.listen(port)
        return this
    }

    protected initRPCs(clientSocket: I.Socket) {
        clientSocket.hook('info', async (sesame?: string) => {
            const rpcs = await Promise.all(this.exporters.map(async exp => {
                const allowed = await this.accessFilter(sesame, exp)
                if (!allowed) return []
                return U.rpcHooker(clientSocket, exp, this.errorHandler, this.sesame)
            }))
            const infos = rpcs.flat()
            if (this.conf.throwOnUnknownRPC) {
                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)
                    }
                })
            }
            return infos
        })


    }

    close(): void {
        this.pio.close()
    }
}