@ariva-mds/mds 2.41.0 → 2.42.0

package/lib/cjs/api/MarketstateUpdate.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketstateUpdate = void 0;
+class MarketstateUpdate {
+    constructor(state, update) {
+        this.state = state;
+        this.update = update;
+    }
+}
+exports.MarketstateUpdate = MarketstateUpdate;

package/lib/cjs/api/MdsAuthdata.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdsAuthdata = void 0;
+class MdsAuthdata {
+    constructor(token) {
+        this.token = token;
+    }
+}
+exports.MdsAuthdata = MdsAuthdata;

package/lib/cjs/api/MdsConnection.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdsConnection = void 0;
+const reconnecting_websocket_1 = __importDefault(require("reconnecting-websocket"));
+const MdsConnectionState_1 = require("./MdsConnectionState");
+const RunningRequest_1 = require("./RunningRequest");
+const rxjs_1 = require("rxjs");
+const MarketstateUpdate_1 = require("./MarketstateUpdate");
+const models_1 = require("../models");
+const lrucache_1 = require("../lrucache");
+class MdsConnection {
+    /**
+     * construct an MdsConnection
+     */
+    constructor(websocketUrl, authdataCallback, options = { debug: false }) {
+        this.state = new MdsConnectionState_1.MdsConnectionState();
+        this.waitingForAuthentification = [];
+        this.waitingForReconnect = [];
+        this.nextGeneratedRequestId = 0;
+        this.runningRequests = new Map();
+        this.isDebug = false;
+        this.reconnectTimer = undefined;
+        /**
+         * gets the basic information about a source
+         */
+        this.sourceCache = undefined;
+        /**
+         * gets the basic information about a source
+         */
+        this.masterdataCache = undefined;
+        /**
+         * gets the tradingtime for a source
+         * */
+        this.tradingtimeCache = undefined;
+        /**
+         * gets the tradingtime for a source
+         * */
+        this.tradingtimeAnalysisCache = undefined;
+        this.authdataCallback = authdataCallback;
+        this.isDebug = options.debug ? true : false;
+        this.websocket = new reconnecting_websocket_1.default(websocketUrl, [], options.wsOptions);
+        const outer = this;
+        // open-handler -> resend open requests from previous connection
+        this.websocket.onopen = function () {
+            outer.debug(`websocket open, resending ${outer.waitingForReconnect.length} items`);
+            outer.state.connectionOpened();
+            for (const request of outer.waitingForReconnect) {
+                outer.sendAsSoonAsAuthenticationPermits(request.request);
+            }
+        };
+        // close handler -> store open requests for resending on reconnect
+        this.websocket.onclose = function () {
+            outer.debug(`websocket closed, queuing ${outer.waitingForReconnect.length} items`);
+            outer.state.connectionClosed();
+            outer.waitingForReconnect = Array.from(outer.runningRequests.values());
+        };
+        this.websocket.onmessage = (e) => {
+            outer.processWebsocketMessageEvent(e);
+        };
+        this.stayAuthenticated();
+        this.reconnectTimer = setInterval(() => {
+            if (!outer.state.isTimedOut()) {
+                outer.debug("websocket timed out, calling reconnect");
+                outer.state.forcedDisconnect();
+                outer.websocket.reconnect();
+            }
+        }, 1000);
+    }
+    close() {
+        if (this.reconnectTimer) {
+            clearInterval(this.reconnectTimer);
+        }
+        this.websocket.close();
+    }
+    /**
+     * create a hearbeat observable that can be subscribed to
+     */
+    heartbeat() {
+        return this.observable({ 'heartbeat': {} })
+            .pipe((0, rxjs_1.map)((x) => x.dataHeartbeat));
+    }
+    /**
+     * create a MarketstateUpdate observable that can be subscribed to, contains both full state and delta for every marketstate
+     */
+    marketstates(marketstateQueries) {
+        const full = new Map();
+        return this.marketstateUpdates(marketstateQueries)
+            .pipe((0, rxjs_1.map)((update) => {
+            let existingEntry = update.marketstateId ? full.get(update.marketstateId) : undefined;
+            if (update.marketstateId) {
+                if (existingEntry) {
+                    existingEntry = this.updateExistingMarketstateWithDeltaUpdate(existingEntry, update);
+                }
+                else {
+                    existingEntry = update;
+                }
+                full.set(update.marketstateId, existingEntry);
+            }
+            return new MarketstateUpdate_1.MarketstateUpdate(existingEntry, update);
+        }));
+    }
+    /**
+     * create a Marketstate observable that cn be subscribed to, contains only delta for every marketstate
+     */
+    marketstateUpdates(marketstateQueries) {
+        return this.observable({ 'subscribeMarketstates': { 'marketstateQueries': marketstateQueries } })
+            .pipe((0, rxjs_1.map)((x) => (0, models_1.MarketstateResponseSearchFromJSON)(x.dataMarketstate)));
+    }
+    /**
+     * create a Marketstate observable that can be subscribed to, contains only full state for every marketstate
+     */
+    marketstatesStates(marketstateQueries) {
+        return this.marketstates(marketstateQueries).pipe((0, rxjs_1.map)((x) => x.state));
+    }
+    /**
+     * sets the priority for sources
+     */
+    priority(sources) {
+        return this.promise({ 'priority': { 'sources': sources } });
+    }
+    source(source) {
+        if (this.sourceCache == undefined) {
+            const outer = this;
+            this.sourceCache = new lrucache_1.LruCache(source => outer.promise({ 'getSource': { 'sourceId': source } }).then(state => (0, models_1.SourcedataFromJSON)(state.dataSource)), 3000);
+        }
+        return this.sourceCache.get(source);
+    }
+    masterdata(instrumentId) {
+        if (this.masterdataCache == undefined) {
+            const outer = this;
+            this.masterdataCache = new lrucache_1.LruCache(instrumentId => outer.promise({ 'getInstrumentMasterdata': { 'instrumentId': instrumentId } }).then(state => (0, models_1.MasterdataMergedSummaryWithIdFromJSON)(state.dataMasterdata)), 3000);
+        }
+        return this.masterdataCache.get(instrumentId);
+    }
+    tradingtime(sourceId) {
+        if (this.tradingtimeCache == undefined) {
+            const outer = this;
+            this.tradingtimeCache = new lrucache_1.LruCache(sourceId => outer.promise({ 'getTradingtime': { 'sourceId': sourceId } }).then(state => (0, models_1.TradingtimeFromJSON)(state.dataTradingtime)), 3000);
+        }
+        return this.tradingtimeCache.get(sourceId);
+    }
+    tradingtimeAnalysis(sourceId, date) {
+        if (this.tradingtimeAnalysisCache == undefined) {
+            const outer = this;
+            this.tradingtimeAnalysisCache = new lrucache_1.LruCache(parameter => outer.promise({ 'getTradingtimeAnalysis': { 'sourceId': parameter.sourceId, 'date': parameter.date } }).then(state => (0, models_1.TradingtimeInfoReplyFromJSON)(state.dataTradingtimeAnalysis)), 3000);
+        }
+        return this.tradingtimeAnalysisCache.get({ sourceId: sourceId, date: date });
+    }
+    /**
+     * Returns a list of all Listings for the Instrument
+     * */
+    instrumentsListings(instrumentId, sourceId) {
+        return this.observable({ 'listInstrumentListings': { 'instrumentId': instrumentId, 'sourceId': sourceId } }).pipe((0, rxjs_1.map)(state => (0, models_1.ListingdataWithIdAndQualityFromJSON)(state.dataListing)));
+    }
+    /**
+     * Returns a list of all Trades for the Instrument
+     * */
+    timeseries(marketstateId, resolution, start = undefined, end = undefined) {
+        const args = { resolution: resolution, marketstateId: marketstateId };
+        args.start = start instanceof Date ? start?.toISOString() : start;
+        args.end = end instanceof Date ? end?.toISOString() : end;
+        return this.observable({ 'subscribeTimeseries': args }).pipe((0, rxjs_1.map)(state => (0, models_1.TimeseriesDataFromJSON)(state.timeseries)));
+    }
+    /**
+     * Returns a list of all Trades for the Instrument
+     * */
+    timeseriesSnapshot(marketstateId, resolution, start = undefined, end = undefined) {
+        const args = { resolution: resolution, marketstateId: marketstateId };
+        args.start = start instanceof Date ? start?.toISOString() : start;
+        args.end = end instanceof Date ? end?.toISOString() : end;
+        return this.observable({ 'listTimeseries': args }).pipe((0, rxjs_1.map)(state => (0, models_1.TimeseriesDataFromJSON)(state.timeseries)));
+    }
+    updateExistingMarketstateWithDeltaUpdate(existingEntry, update) {
+        const existingJson = (0, models_1.MarketstateResponseSearchToJSON)(existingEntry);
+        const updateJson = (0, models_1.MarketstateResponseSearchToJSON)(update);
+        for (const key in updateJson) {
+            if (!(updateJson[key] == undefined)) {
+                existingJson[key] = updateJson[key];
+            }
+        }
+        return (0, models_1.MarketstateResponseSearchFromJSON)(existingJson);
+    }
+    sendAsSoonAsAuthenticationPermits(request) {
+        if (this.state.isAuthenticated || request.subscribeAuthentication) {
+            this.websocket.send(JSON.stringify(request));
+        }
+        else {
+            this.waitingForAuthentification.push(request);
+        }
+    }
+    stayAuthenticated() {
+        const outer = this;
+        new rxjs_1.Observable((subscriber) => {
+            this.authdataCallback().then((mdsAuthdata) => outer.observable({ 'subscribeAuthentication': mdsAuthdata })).then((observable) => observable.subscribe({
+                next(x) {
+                    const seconds = x?.dataAuthentication?.secondsToLive;
+                    if (seconds && seconds > 30) {
+                        subscriber.next(x);
+                        for (const requestParameter of outer.waitingForAuthentification) {
+                            outer.websocket.send(JSON.stringify(requestParameter));
+                        }
+                        outer.waitingForAuthentification = [];
+                        outer.state.authenticationAccepted();
+                    }
+                },
+                complete() {
+                    outer.state.authenticationEnded();
+                    subscriber.complete();
+                },
+                error(e) {
+                    outer.error(e);
+                    outer.state.authenticationEnded();
+                    subscriber.complete();
+                }
+            })).catch((error) => {
+                outer.error(error);
+                outer.state.authenticationEnded();
+                subscriber.error(error);
+            });
+        }).pipe((0, rxjs_1.retry)({ delay: 2000 }), (0, rxjs_1.repeat)({ delay: 2000 }))
+            .subscribe({
+            next(n) { outer.debug(`auth outer ${JSON.stringify(n)}`); },
+            error(e) { outer.error(`auth error ${JSON.stringify(e)}`); },
+            complete() { outer.debug("auth completed"); }
+        });
+    }
+    generateNextRequestId() {
+        return "request-" + this.nextGeneratedRequestId++;
+    }
+    observable(req) {
+        const requestId = this.generateNextRequestId();
+        req.requestId = requestId;
+        const outer = this;
+        const observable = new rxjs_1.Observable((subscriber) => {
+            outer.runningRequests.set(requestId, RunningRequest_1.RunningRequest.withObservable(req, subscriber));
+            outer.sendAsSoonAsAuthenticationPermits(req);
+            // Provide a way of canceling and disposing the resources
+            return function unsubscribe() {
+                const runningRequest = outer.runningRequests.get(requestId);
+                if (runningRequest && runningRequest.observableSubscriber) {
+                    outer.runningRequests.delete(requestId);
+                    outer.websocket.send(JSON.stringify({
+                        'cancel': { 'requestId': requestId }
+                    }));
+                }
+            };
+        });
+        return observable;
+    }
+    promise(req) {
+        const requestId = this.generateNextRequestId();
+        req.requestId = requestId;
+        const outer = this;
+        const promise = new Promise((resolve, reject) => {
+            outer.runningRequests.set(requestId, RunningRequest_1.RunningRequest.withPromise(req, resolve, reject));
+            outer.sendAsSoonAsAuthenticationPermits(req);
+        });
+        return promise;
+    }
+    processWebsocketMessageEvent(e) {
+        if (e?.data) {
+            const msg = JSON.parse(e.data);
+            this.debug("we received " + JSON.stringify(msg));
+            this.state.messageReceived();
+            if (msg.requestId) {
+                const request = this.runningRequests.get(msg.requestId);
+                if (request) {
+                    if (request.promiseResolve && request.promiseReject) {
+                        if (msg.isError) {
+                            request.promiseReject(msg.errorMessage);
+                            this.runningRequests.delete(msg.requestId);
+                        }
+                        else if (msg.isComplete == true) {
+                            request.promiseResolve(msg);
+                            this.runningRequests.delete(msg.requestId);
+                        }
+                        else {
+                            request.promiseReject(msg.errorMessage);
+                            this.runningRequests.delete(msg.requestId);
+                        }
+                    }
+                    else if (request.observableSubscriber) {
+                        if (msg.isError == true) {
+                            this.runningRequests.delete(msg.requestId);
+                            request.observableSubscriber.error(msg.errorMessage);
+                        }
+                        else if (msg.isComplete == true) {
+                            this.runningRequests.delete(msg.requestId);
+                            request.observableSubscriber.complete();
+                        }
+                        else {
+                            request.observableSubscriber.next(msg);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    debug(s) {
+        if (this.isDebug)
+            console.log(s);
+    }
+    error(s) {
+        console.error(s);
+    }
+}
+exports.MdsConnection = MdsConnection;

package/lib/cjs/api/MdsConnectionState.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdsConnectionState = void 0;
+class MdsConnectionState {
+    constructor() {
+        this.isConnected = false;
+        this.isAuthenticated = false;
+        this.lastUpdate = new Date();
+    }
+    connectionOpened() {
+        this.isConnected = true;
+        this.isAuthenticated = false;
+        this.lastUpdate = new Date();
+    }
+    connectionClosed() {
+        this.isConnected = false;
+        this.isAuthenticated = false;
+    }
+    authenticationAccepted() {
+        this.isAuthenticated = true;
+    }
+    authenticationEnded() {
+        this.isAuthenticated = false;
+    }
+    messageReceived() {
+        this.lastUpdate = new Date();
+    }
+    isTimedOut() {
+        return Date.now() - this.lastUpdate.getTime() < 20000; // 20 seconds timeout
+    }
+    forcedDisconnect() {
+        this.lastUpdate = new Date();
+    }
+}
+exports.MdsConnectionState = MdsConnectionState;

package/lib/cjs/api/MdsOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/api/RunningRequest.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunningRequest = void 0;
+class RunningRequest {
+    constructor(request) {
+        this.request = request;
+    }
+    static withObservable(request, observableSubscriber) {
+        const n = new RunningRequest(request);
+        n.observableSubscriber = observableSubscriber;
+        return n;
+    }
+    static withPromise(request, resolve, reject) {
+        const n = new RunningRequest(request);
+        n.promiseResolve = resolve;
+        n.promiseReject = reject;
+        return n;
+    }
+}
+exports.RunningRequest = RunningRequest;

package/lib/cjs/api/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MarketstateUpdate"), exports);
+__exportStar(require("./MdsAuthdata"), exports);
+__exportStar(require("./MdsConnection"), exports);
+__exportStar(require("./MdsConnectionState"), exports);
+__exportStar(require("./MdsOptions"), exports);
+__exportStar(require("./RunningRequest"), exports);