@actyx/sdk/lib/v2/multiplexedWebsocket.js

Actyx SDK

"use strict";
/*
 * Actyx SDK: Functions for writing distributed apps
 * deployed on peer-to-peer networks, without any servers.
 *
 * Copyright (C) 2021 Actyx AG
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.mkConfig = exports.MultiplexedWebsocket = exports.ResponseMessage = void 0;
const t = require("io-ts");
const globals = require("../globals");
const multiplexedWebSocket_1 = require("../internal_common/multiplexedWebSocket");
const util_1 = require("../util");
const rxjs_1 = require("../../node_modules/rxjs");
const Either_1 = require("fp-ts/lib/Either");
const error_1 = require("../util/error");
const utils_1 = require("./utils");
const activeRequestInternals = globals.activeRequests[utils_1.GlobalInternalSymbol];
const NextMessage = t.readonly(t.type({
    type: t.literal("next" /* Next */),
    requestId: multiplexedWebSocket_1.RequestId,
    payload: t.array(t.unknown),
}));
const CompleteMessage = t.readonly(t.type({
    type: t.literal("complete" /* Complete */),
    requestId: multiplexedWebSocket_1.RequestId,
}));
const ErrorMessage = t.readonly(t.type({
    type: t.literal("error" /* Error */),
    requestId: multiplexedWebSocket_1.RequestId,
    // TODO refine, we have the following on the Rust side:
    // UnknownEndpoint { endpoint: String },
    // InternalError,
    // BadRequest,
    // ServiceError { value: Value },
    kind: t.unknown,
}));
exports.ResponseMessage = t.union([NextMessage, CompleteMessage, ErrorMessage]);
class MultiplexedWebsocket {
    constructor(config, redialAfter = 2000) {
        this.ws = new multiplexedWebSocket_1.MultiplexedWebsocket(config, redialAfter);
    }
    request(serviceId, payload) {
        const sym = Symbol();
        const request = this.ws.request(serviceId, payload).pipe((0, rxjs_1.finalize)(() => activeRequestInternals.unregister(sym)), (0, rxjs_1.concatMap)((msg) => msg.payload), (0, rxjs_1.catchError)((err) => {
            const e = ErrorMessage.decode(err);
            return (0, Either_1.isRight)(e)
                ? (0, rxjs_1.throwError)(() => new Error((0, error_1.stringifyError)(e.right.kind)))
                : (0, rxjs_1.throwError)(() => err);
        }));
        activeRequestInternals.register(sym, {
            serviceId,
            payload,
            time: new Date(),
        });
        return request;
    }
    close() {
        this.ws.close();
    }
    errors() {
        return this.ws.errors;
    }
}
exports.MultiplexedWebsocket = MultiplexedWebsocket;
const serializer = (msg) => {
    // rxjs websocket only has one type, but we know that we serialize only requests
    return JSON.stringify(multiplexedWebSocket_1.RequestMessage.encode(msg));
};
const deserializer = (msg) => (0, util_1.validateOrThrow)(exports.ResponseMessage)(JSON.parse(msg.data));
const mkConfig = (url) => ({
    url,
    serializer,
    deserializer,
});
exports.mkConfig = mkConfig;
//# sourceMappingURL=multiplexedWebsocket.js.map