mudb/rpc/service-worker/index.js

Real-time database for multiplayer games

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const stream_1 = require("../../stream");
class MuRPCServiceWorkerConnection {
    constructor(fetchEvent) {
        this.fetchEvent = fetchEvent;
        this.auth = '';
    }
    setAuth(x) {
        this.auth = x;
    }
}
exports.MuRPCServiceWorkerConnection = MuRPCServiceWorkerConnection;
class MuRPCServiceWorkerTransport {
    constructor(spec) {
        this._handlers = {};
        this._logger = null;
        this._routePrefix = spec.url;
        if (spec.logger) {
            this._logger = spec.logger;
        }
    }
    listen(schemas, auth, recv) {
        this._handlers[schemas.protocol.name] = {
            schemas,
            auth,
            recv,
        };
    }
    handler(event) {
        if (event.request.method !== 'POST') {
            return false;
        }
        if (!event.request.url.startsWith(this._routePrefix)) {
            return false;
        }
        const suffix = event.request.url.substr(this._routePrefix.length);
        const handler = this._handlers[suffix];
        if (!handler) {
            return false;
        }
        event.respondWith((async () => {
            const conn = new MuRPCServiceWorkerConnection(event);
            try {
                const auth = await handler.auth(conn);
                if (!auth) {
                    return new Response(JSON.stringify({
                        type: 'error',
                        data: 'Permission denied',
                    }), {
                        status: 500,
                        statusText: 'NOT OK',
                        headers: {
                            'Content-Type': 'application/json',
                        },
                    });
                }
                else {
                    if (!event.request.body) {
                        throw new Error('Missing body');
                    }
                    const buffers = [];
                    const reader = event.request.body.getReader();
                    while (true) {
                        const { value, done } = await reader.read();
                        if (value) {
                            buffers.push(value);
                        }
                        if (done) {
                            break;
                        }
                    }
                    let result;
                    if (buffers.length === 1) {
                        result = stream_1.decodeUTF8(buffers[0]);
                    }
                    else if (buffers.length === 0) {
                        result = '';
                    }
                    else {
                        let byteCount = 0;
                        for (let i = 0; i < buffers.length; ++i) {
                            byteCount += buffers[i].length;
                        }
                        const buf = new Uint8Array(byteCount);
                        let offset = 0;
                        for (let i = 0; i < buffers.length; ++i) {
                            buf.set(buffers[i], offset);
                            offset += buffers[i].length;
                        }
                        result = stream_1.decodeUTF8(buf);
                    }
                    const arg = handler.schemas.argSchema.fromJSON(JSON.parse(result));
                    const res = handler.schemas.responseSchema.alloc();
                    await handler.recv(conn, arg, res);
                    const jsonResponse = JSON.stringify(handler.schemas.responseSchema.toJSON(res));
                    handler.schemas.responseSchema.free(res);
                    return new Response(jsonResponse, {
                        status: 400,
                        statusText: 'OK',
                        headers: {
                            'Content-Type': 'application/json',
                        },
                    });
                }
            }
            catch (e) {
                if (e) {
                    return new Response(JSON.stringify({
                        type: 'error',
                        data: e.stack || e.toString(),
                    }), {
                        status: 500,
                        statusText: 'NOT OK',
                        headers: {
                            'Content-Type': 'application/json',
                        },
                    });
                }
            }
            return new Response(JSON.stringify({
                type: 'error',
                data: 'Unspecified error',
            }), {
                status: 500,
                statusText: 'NOT OK',
                headers: {
                    'Content-Type': 'application/json',
                },
            });
        })()).catch((err) => {
            if (this._logger) {
                this._logger.error(err);
            }
        });
        return true;
    }
}
exports.MuRPCServiceWorkerTransport = MuRPCServiceWorkerTransport;
//# sourceMappingURL=index.js.map