@deepkit/rpc-tcp/dist/esm/src/server.js

import { asyncOperation, parseHost } from '@deepkit/core';
import { existsSync, mkdirSync, unlinkSync } from 'fs';
import { createServer } from 'net';
import { WebSocketServer } from 'ws';
import { dirname } from 'path';
/**
 * Uses the node `net` module to create a server. Supports unix sockets.
 */
export class RpcTcpServer {
    constructor(kernel, host) {
        this.kernel = kernel;
        this.host = parseHost(host);
        if (this.host.isUnixSocket) {
            if (existsSync(this.host.unixSocket))
                unlinkSync(this.host.unixSocket);
            mkdirSync(dirname(this.host.unixSocket), { recursive: true });
        }
    }
    start() {
        return asyncOperation((resolve, reject) => {
            this.server = createServer();
            this.server.on('listening', () => {
                resolve(true);
            });
            this.server.on('error', (err) => {
                reject(new Error('Could not start broker server: ' + err));
            });
            this.server.on('connection', (socket) => {
                const connection = this.kernel?.createConnection({
                    write(b) {
                        connection.sendBinary(b, (data) => socket.write(data));
                    },
                    clientAddress() {
                        return socket.remoteAddress || '';
                    },
                    close() {
                        socket.destroy();
                    },
                    bufferedAmount() {
                        return socket.writableLength || 0;
                    },
                });
                socket.on('data', (data) => {
                    connection.feed(data);
                });
                socket.on('close', () => {
                    connection.close();
                });
                socket.on('error', (error) => {
                    connection.close(error);
                });
            });
            if (this.host.isUnixSocket) {
                this.server.listen(this.host.unixSocket);
            }
            else {
                this.server.listen(this.host.port || 8811, this.host.host);
            }
        });
    }
    close() {
        this.server?.close();
    }
}
export class RpcWebSocketServer {
    constructor(kernel, host) {
        this.kernel = kernel;
        this.host = parseHost(host);
        if (this.host.isUnixSocket && existsSync(this.host.unixSocket)) {
            if (existsSync(this.host.unixSocket))
                unlinkSync(this.host.unixSocket);
            mkdirSync(dirname(this.host.unixSocket), { recursive: true });
        }
    }
    close() {
        this.server?.close();
    }
    start(options) {
        const defaultOptions = { host: this.host.host, port: this.host.port };
        this.server = new WebSocketServer({ ...defaultOptions, ...options });
        this.server.on('connection', (ws, req) => {
            const connection = this.kernel?.createConnection({
                writeBinary(message) {
                    ws.send(message);
                },
                close() {
                    ws.close();
                },
                bufferedAmount() {
                    return ws.bufferedAmount;
                },
                clientAddress() {
                    return req.socket.remoteAddress || '';
                },
            });
            ws.on('message', (message) => {
                connection.feed(message);
            });
            ws.on('close', () => {
                connection.close();
            });
            ws.on('error', (error) => {
                connection.close(error);
            });
        });
    }
}
//# sourceMappingURL=server.js.map