@factset/frontgate-js-sdk 6.11.1 → 7.0.1

package/dist/lib/node/connection/LatencyTracker.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LatencyTracker = void 0;
-const message_1 = require("../message");
-class LatencyTracker {
-    constructor(cb, conn) {
-        this.cb = cb;
-        this.conn = conn;
-        this.isRequestPending = false;
-        this.request = new message_1.PingRequest();
-    }
-    start(interval) {
-        if (this.timeout !== undefined) {
-            throw new Error('LatencyTracker already running!');
-        }
-        this.conn.setMessageProcessor('Foundation::PingResponse', this.handlePingResponse.bind(this));
-        this.timeout = setInterval(() => {
-            if (!this.conn.isAuthenticated()) {
-                this.cb(undefined, undefined, undefined, 'Skipping ping request, connection not authenticated!');
-                return;
-            }
-            if (this.isRequestPending) {
-                if (Date.now() - this.request.timeAtSender < LatencyTracker.MAX_RESPONSE_LATENCY_MS) {
-                    this.cb(this.request.timeAtSender, undefined, undefined, 'Skipping ping request, previous request pending!');
-                    return;
-                }
-                this.cb(this.request.timeAtSender, undefined, undefined, 'Clearing ping request, previous request exceeded timeout!');
-            }
-            this.isRequestPending = true;
-            this.request.resetTimeAtSender();
-            void this.conn.send(this.request.getPtlMessage());
-        }, interval);
-        if (typeof window === 'undefined') {
-            this.timeout.unref();
-        }
-    }
-    stop() {
-        clearInterval(this.timeout);
-        this.timeout = undefined;
-        this.isRequestPending = false;
-        this.conn.removeMessageProcessor('Foundation::PingResponse');
-    }
-    handlePingResponse(msg) {
-        const resp = new message_1.PingResponse(msg);
-        this.cb(resp.timeOfRequest, resp.latencyTotal, resp.latencyAtPeer, undefined);
-        this.isRequestPending = false;
-        return false;
-    }
-}
-exports.LatencyTracker = LatencyTracker;
-LatencyTracker.MAX_RESPONSE_LATENCY_MS = 60 * 1000;

package/dist/lib/node/connection/MessageProcessor.js

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

package/dist/lib/node/connection/util/Encoding.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Encoding = void 0;
-class Encoding {
-    static isSupportedEncoding(encoding) {
-        return Encoding.SUPPORTED_ENCODINGS.includes(encoding);
-    }
-    static isPlainJson(encoding) {
-        return Encoding.PLAIN_JSON_ENCODINGS.includes(encoding);
-    }
-    static isCompressedJson(encoding) {
-        return Encoding.COMPRESSED_ENCODINGS.includes(encoding);
-    }
-}
-exports.Encoding = Encoding;
-Encoding.SUPPORTED_ENCODINGS = ['jsjson-v2', 'jsjsonc-v2'];
-Encoding.PLAIN_JSON_ENCODINGS = ['jsjson-v2'];
-Encoding.COMPRESSED_ENCODINGS = Encoding.SUPPORTED_ENCODINGS.filter((enc) => enc.includes('jsonc'));

package/dist/lib/node/core/RequestModule.js

@@ -1,353 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestModule = exports.DEFAULT_REQUEST_MODULE_OPTIONS = void 0;
-const rxjs_1 = require("rxjs");
-const message_1 = require("../message");
-const MessageFactory_1 = require("../message/MessageFactory");
-const authentication_1 = require("../authentication");
-const TimeOutWrapper_1 = require("../util/TimeOutWrapper");
-const functions_1 = require("../common/functions");
-const api_1 = require("@opentelemetry/api");
-const constants_1 = require("../common/constants");
-exports.DEFAULT_REQUEST_MODULE_OPTIONS = {
-    defaultTimeoutInMs: constants_1.DEFAULT_TIMEOUT_IN_MS,
-    defaultTimeoutTokenInMs: constants_1.DEFAULT_TIMEOUT_TOKEN_IN_MS,
-    maxTimeoutsBeforeReconnect: constants_1.DEFAULT_MAX_TIMEOUTS_BEFORE_RECONNECT,
-    flagPermissionDenied: constants_1.DEFAULT_FLAG_PERMISSION_DENIED,
-    replaySubjectBufferSize: constants_1.DEFAULT_REPLAY_SUBJECT_BUFFER_SIZE,
-};
-class RequestModule {
-    constructor(getConnection, logger, options = exports.DEFAULT_REQUEST_MODULE_OPTIONS) {
-        this.getConnection = getConnection;
-        this.logger = logger;
-        this.options = options;
-        this.rejectResponsesTimeout = [50, 100, 200, 400, 800, 1600, 3200];
-        this.timeoutCounter = 0;
-        this.subscription = rxjs_1.Subscription.EMPTY;
-        this.chunks = new Map();
-        this.replaySubjectBufferSize = options.replaySubjectBufferSize;
-        this.requestSubject = new rxjs_1.ReplaySubject(this.replaySubjectBufferSize);
-        this.jobs = new Map();
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    reset() {
-        this.logger.trace('requestModule.reset()');
-        this.requestSubject.complete();
-        this.requestSubject = new rxjs_1.ReplaySubject(this.replaySubjectBufferSize);
-        this.chunks.clear();
-    }
-    async requestWithQuality(msg, quality, timeOutInMs = this.options.defaultTimeoutInMs) {
-        if (quality === 'BST') {
-            return this.requestBestQuality(msg, timeOutInMs);
-        }
-        if (quality && Object.keys(message_1.TransportLayerClientRequestHeader.PRICE_QUALITY).includes(quality)) {
-            msg.header.setQuality(quality);
-        }
-        return this.request(msg, timeOutInMs);
-    }
-    async requestEndpoint(method, path, data, options, timeOutInMs = this.options.defaultTimeoutInMs) {
-        const highLevelRequest = new message_1.HighLevelRequest(method, path, data, options);
-        try {
-            const response = await this.request(highLevelRequest, timeOutInMs);
-            this.logger.info(`Endpoint Response: [${method}] ${path}`, { request: data, response: response.data });
-            return { response, data: response.data };
-        }
-        catch (err) {
-            const error = (0, functions_1.errorHandler)(err);
-            this.logger.warn(`Endpoint Request Failed. ${error.message}`, err);
-            throw error;
-        }
-    }
-    async requestProxyEndpoint(method, path, body, options, timeOutInMs = this.options.defaultTimeoutInMs) {
-        const httpProxyRequest = new message_1.HTTPProxyRequest(method, path, options);
-        if (body) {
-            httpProxyRequest.setBody(body);
-        }
-        try {
-            const response = await this.request(httpProxyRequest, timeOutInMs);
-            this.logger.info(`Proxy Endpoint Response: [${method}] ${path}`, { request: body, response: response.data });
-            return { response, data: response.data };
-        }
-        catch (err) {
-            const error = (0, functions_1.errorHandler)(err);
-            this.logger.warn(`Proxy Endpoint Request Failed. ${error.message}`, err);
-            throw error;
-        }
-    }
-    async requestAuthenticationToken(lifetimeSeconds, idUser, idApplication, timeOutInMs = this.options.defaultTimeoutTokenInMs) {
-        const request = new message_1.AuthenticationTokenRequest(lifetimeSeconds, idUser, idApplication, timeOutInMs);
-        const response = await this.request(request, timeOutInMs);
-        return response.getToken();
-    }
-    async requestAuthenticationTokenExpiry(lifetimeSeconds, idUser, idApplication, timeOutInMs = this.options.defaultTimeoutTokenInMs, otp = false) {
-        const request = new message_1.AuthenticationTokenRequest(lifetimeSeconds, idUser, idApplication, timeOutInMs, otp);
-        const res = (await this.request(request, timeOutInMs));
-        const token = res.getToken();
-        const expiry = res.getExpiry();
-        return { token, expiry };
-    }
-    async requestAuthenticationTokenFactorsForCookieAuthentication(lifetimeSeconds, idUser, idApplication, timeOutInMs = this.options.defaultTimeoutTokenInMs) {
-        const token = await this.requestAuthenticationToken(lifetimeSeconds, idUser, idApplication, timeOutInMs);
-        return new authentication_1.CookieTokenAuthenticationFactors(token);
-    }
-    onConnection() {
-        const connection = this.getConnection();
-        if (!connection) {
-            throw new Error('Runtime error: Please assign a connection to the client instance.');
-        }
-        if (this.subscription.closed) {
-            connection.onMessage = this.handleMessage.bind(this);
-            this.subscription = this.requestSubject.subscribe(this.sendRequest.bind(this));
-            this.logger.trace('onConnection');
-        }
-    }
-    setUpdateMessageHandler(handler) {
-        this.updateMessageHandler = handler;
-    }
-    setLossMessageHandler(handler) {
-        this.lossMessageHandler = handler;
-    }
-    async request(msg, timeOutInMs = this.options.defaultTimeoutInMs) {
-        const connection = this.getConnection();
-        if (!connection) {
-            throw new Error('Runtime error: Please assign a connection to the client instance.');
-        }
-        if (RequestModule.supportedPermissionDeniedResponseMessages(msg) && this.options.flagPermissionDenied) {
-            msg.header.setFlag('permission_denied_response');
-        }
-        if (RequestModule.supportsChunkedResponse(msg)) {
-            msg.header.setFlag('allow_chunked_response');
-        }
-        msg.header.setTimeout(timeOutInMs);
-        return api_1.trace.getTracer('MDG2Client').startActiveSpan('RequestModule.request', async (span) => {
-            msg.header.setTracing(span.spanContext());
-            const rejectReason = `Request timeout reached (${timeOutInMs} ms) for ${msg.getPtlMessage().Message}`;
-            const promise = new Promise((resolve, reject) => {
-                this.requestSubject.next({
-                    msg,
-                    insertedAt: Date.now(),
-                    resolve,
-                    reject,
-                });
-            });
-            return TimeOutWrapper_1.TimeoutWrapper.wrap(promise, timeOutInMs, rejectReason)
-                .then((message) => {
-                this.logger.trace('Reset timeout counter');
-                this.timeoutCounter = 0;
-                return message;
-            })
-                .catch((e) => {
-                if (e.code === 408) {
-                    this.timeoutCounter++;
-                    this.logger.trace(`Increment timeout counter to ${this.timeoutCounter}`);
-                    const maxTimeouts = this.options.maxTimeoutsBeforeReconnect;
-                    if (this.timeoutCounter === maxTimeouts) {
-                        this.logger.warn(`Closing connection due to max number of timeouts reached (${maxTimeouts})`);
-                        connection.close(true).catch((err) => {
-                            this.logger.error('Error while closing connection', err);
-                        });
-                        this.timeoutCounter = 0;
-                    }
-                }
-                else {
-                    const error = (0, functions_1.errorHandler)(e);
-                    this.logger.trace(`Endpoint Request Failed. ${error.message}`);
-                }
-                throw e;
-            })
-                .finally(() => {
-                span.end();
-            });
-        });
-    }
-    reRequest(job) {
-        this.requestSubject.next({ msg: job.msg, resolve: job.resolve, reject: job.reject });
-    }
-    async requestBestQuality(msg, timeOutInMs = this.options.defaultTimeoutInMs) {
-        const orderedPriceQuality = ['RLT', 'DLY', 'EOD'];
-        for (let i = 0; i < orderedPriceQuality.length; i++) {
-            msg.header.setQuality(orderedPriceQuality[i]);
-            const promise = this.request(msg, timeOutInMs);
-            try {
-                return await promise;
-            }
-            catch (err) {
-                this.logger.debug(`Failed to perform request in "${orderedPriceQuality[i]}" quality.`, err, msg);
-            }
-            if (i === orderedPriceQuality.length - 1) {
-                return promise;
-            }
-        }
-        return { Message: 'Should never happen', Version: 1 };
-    }
-    prependCollectedChunks(finalResponse) {
-        const chunks = this.chunks.get(finalResponse.header.id_job);
-        if (chunks === undefined) {
-            return;
-        }
-        this.logger.trace('Prepending previous chunks to message', finalResponse);
-        let chunkedContent = '';
-        chunks.forEach((partialResponse) => {
-            this.logger.trace('Prepending previous chunk to message', partialResponse);
-            chunkedContent += partialResponse.body.value;
-            finalResponse.header.processingTime += partialResponse.header.processingTime;
-        });
-        chunkedContent += finalResponse.body.value;
-        finalResponse.body.value = chunkedContent;
-        this.chunks.delete(finalResponse.header.id_job);
-    }
-    collectChunk(partialResponse) {
-        if (this.chunks.has(partialResponse.header.id_job)) {
-            this.chunks.get(partialResponse.header.id_job)?.push(partialResponse);
-        }
-        else {
-            this.chunks.set(partialResponse.header.id_job, [partialResponse]);
-        }
-    }
-    handleMessage(rawMessage) {
-        let msg;
-        if ((0, message_1.isHighLevelResponseMessage)(rawMessage)) {
-            if (MessageFactory_1.MessageFactory.hasNextChunk(rawMessage)) {
-                this.logger.trace('Received message chunk', rawMessage);
-                this.collectChunk(rawMessage);
-                return;
-            }
-            this.prependCollectedChunks(rawMessage);
-        }
-        try {
-            msg = MessageFactory_1.MessageFactory.createMessage(rawMessage);
-        }
-        catch (createMessageError) {
-            this.logger.error('Problem while creating message', createMessageError, rawMessage);
-            return;
-        }
-        const { jobId } = msg;
-        const job = this.jobs.get(jobId);
-        if (msg.isUpdateMessage() && this.updateMessageHandler) {
-            this.updateMessageHandler(msg, jobId);
-            return;
-        }
-        if (msg.isLossMessage() && this.lossMessageHandler) {
-            this.lossMessageHandler(msg, jobId);
-            this.jobs.delete(jobId);
-            return;
-        }
-        if (!job) {
-            this.logger.error(`Could not find idJob ${jobId}`, rawMessage);
-            return;
-        }
-        if ((0, message_1.isRejectResponse)(msg)) {
-            this.logger.debug(`RejectResponse received for idJob ${jobId}`, rawMessage);
-            this.rejectResponseHandler(job);
-            return;
-        }
-        if ((0, message_1.isErrorResponse)(msg) || (0, message_1.isPermissionDeniedResponse)(msg)) {
-            const debugObject = {
-                request: job.request,
-                response: msg,
-            };
-            this.logger.warn(`Received ${msg.name} with idJob: ${jobId}`, debugObject);
-            job.reject(msg);
-            this.jobs.delete(jobId);
-            return;
-        }
-        this.logger.trace(`Received ${msg.name} with idJob: ${jobId}`, msg);
-        this.jobs.delete(jobId);
-        job.resolve(msg);
-    }
-    rejectResponseHandler(job) {
-        const rejectResponseTimeout = this.getRejectResponseTimeout(job.msg.header.getResendCounter());
-        const calculatedTimeout = job.expirationTime - Date.now() - rejectResponseTimeout;
-        if (calculatedTimeout < 1) {
-            const errorMessage = `Timeout for idJob ${job.msg.header.getJobId()}`;
-            this.logger.error(errorMessage);
-            job.reject(new message_1.ErrorResponse({
-                Message: 'Foundation::ErrorResponse',
-                Version: 1,
-                id_job: job.msg.header.getJobId(),
-                reason: 8,
-                details: errorMessage,
-            }));
-        }
-        this.logger.debug(`Retry request after ${rejectResponseTimeout}ms for idJob ${job.msg.header.getJobId()}`);
-        setTimeout(() => {
-            job.msg.header.setTimeout(calculatedTimeout);
-            job.msg.header.countResend();
-            this.reRequest(job);
-        }, rejectResponseTimeout);
-    }
-    getRejectResponseTimeout(resendCounter = 0) {
-        const lastIndex = this.rejectResponsesTimeout.length - 1;
-        return this.rejectResponsesTimeout[resendCounter] ?? this.rejectResponsesTimeout[lastIndex];
-    }
-    async sendRequest(req) {
-        const connection = this.getConnection();
-        if (!connection) {
-            req.reject('Runtime error: Please assign a connection to the client instance.');
-            return;
-        }
-        while (!connection.isAuthenticated()) {
-            if (req.insertedAt && req.insertedAt + req.msg.header.getTimeout() < Date.now()) {
-                req.reject('sendRequest timeout reached');
-                return;
-            }
-            await new Promise((resolve) => {
-                setTimeout(() => {
-                    resolve('Timeout reached');
-                }, 1000);
-            });
-        }
-        req.msg.header.setIdApplication(connection.auth.idApplication);
-        req.msg.header.setIdUser(connection.auth.idUser);
-        const json = req.msg.getPtlMessage();
-        const jobId = connection.send(json).idJob;
-        req.msg.header.setJobId(jobId);
-        const debugMsg = {
-            json,
-        };
-        if ((json.Message === message_1.HighLevelRequest.NAME || json.Message === message_1.HTTPProxyRequest.NAME) && typeof req.msg.getData === 'function') {
-            debugMsg.data = req.msg.getData();
-        }
-        const job = {
-            msg: req.msg,
-            expirationTime: Date.now() + req.msg.header.getTimeout(),
-            resolve: req.resolve,
-            reject: req.reject,
-            request: debugMsg,
-        };
-        this.jobs.set(jobId, job);
-        this.logger.trace(`Sending ${json.Message} with idJob: ${jobId}`, debugMsg);
-    }
-    clearPendingRequests() {
-        this.jobs.forEach((job, jobId) => {
-            const errorResponse = new message_1.ErrorResponse({
-                Message: 'Foundation::ErrorResponse',
-                header: {
-                    id_job: jobId,
-                    id_service: '0',
-                },
-                reason: {
-                    value: 1001,
-                },
-            });
-            job.reject(errorResponse);
-        });
-        this.jobs.clear();
-        this.reset();
-    }
-    static supportedPermissionDeniedResponseMessages(msg) {
-        const supportedMessages = [message_1.HighLevelRequest];
-        for (const supportedMessage of supportedMessages) {
-            if (msg instanceof supportedMessage) {
-                return true;
-            }
-        }
-        return false;
-    }
-    static supportsChunkedResponse(msg) {
-        return msg instanceof message_1.HighLevelRequest && !msg.header.isFlagValueSet('add_subscription');
-    }
-}
-exports.RequestModule = RequestModule;

package/dist/lib/node/core/SubscriptionModule.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubscriptionModule = exports.DEFAULT_SUBSCRIPTION_MODULE_OPTIONS = void 0;
-const constants_1 = require("../common/constants");
-const message_1 = require("../message");
-const EndpointHandler_1 = require("./subscription/EndpointHandler");
-const SubjectManager_1 = require("./subscription/SubjectManager");
-exports.DEFAULT_SUBSCRIPTION_MODULE_OPTIONS = {
-    shouldRestartSubscriptions: false,
-};
-class SubscriptionModule {
-    constructor(requestModule, logger, options = exports.DEFAULT_SUBSCRIPTION_MODULE_OPTIONS) {
-        this.logger = logger;
-        this.options = options;
-        this.subjectManager = new SubjectManager_1.SubjectManager(this.logger);
-        this.handler = {
-            endpoint: new EndpointHandler_1.EndpointHandler(requestModule, this.subjectManager, this.logger),
-        };
-        requestModule.setUpdateMessageHandler(this.updateHandler.bind(this));
-        requestModule.setLossMessageHandler(this.lossHandler.bind(this));
-    }
-    setLogger(logger) {
-        this.logger = logger;
-        this.handler.endpoint.setLogger(logger);
-    }
-    observeEndpoint(method, path, data, options, requestOptions) {
-        return this.handler.endpoint.observe(method, path, data, options, requestOptions);
-    }
-    async unobserveEndpoint(idJob) {
-        return this.handler.endpoint.unobserve(idJob);
-    }
-    restartSubscriptions() {
-        this.handler.endpoint.restartSubscriptions();
-    }
-    clearPendingSubscriptions() {
-        this.subjectManager.jobs.forEach((subject, jobId) => {
-            const lossMsg = new message_1.SubscriptionLossMessage({
-                Message: 'Foundation::SubscriptionLossMessage',
-                Version: 2,
-                header: {
-                    id_job: parseInt(jobId, 10),
-                    id_service: 0,
-                },
-                reason: {
-                    value: 1,
-                },
-            });
-            subject.error(lossMsg);
-        });
-        this.subjectManager.jobs.clear();
-    }
-    clearPendingSubscription(idJob) {
-        this.subjectManager.jobs.forEach((subject, jobId) => {
-            if (idJob === Number(jobId)) {
-                const lossMsg = new message_1.SubscriptionLossMessage({
-                    Message: 'Foundation::SubscriptionLossMessage',
-                    Version: 2,
-                    header: {
-                        id_job: parseInt(jobId, 10),
-                        id_service: 0,
-                    },
-                    reason: {
-                        value: 1,
-                    },
-                });
-                subject.error(lossMsg);
-            }
-        });
-        this.subjectManager.jobs.delete(idJob.toString());
-    }
-    lossHandler(msg) {
-        try {
-            const subject = this.findSubject(msg);
-            const { jobId } = msg;
-            this.logger.debug(`Received Loss Message ${msg.name}`, msg);
-            subject.error(`Subscription lost: ${JSON.stringify(msg)}`);
-            if (this.options.shouldRestartSubscriptions) {
-                this.handler.endpoint.restartSubscription(jobId);
-            }
-        }
-        catch (err) {
-            this.logger.warn('Received Loss Message but could not find corresponding subject', msg);
-        }
-    }
-    updateHandler(msg) {
-        try {
-            const subject = this.findSubject(msg);
-            this.logger.debug(`Received Update Message ${msg.name}`, msg);
-            subject.next(msg);
-        }
-        catch (err) {
-            this.logger.warn('Received Update Message but could not find corresponding subject', msg);
-        }
-    }
-    findSubject(msg) {
-        if ((0, message_1.isHighLevelUpdate)(msg) || (0, message_1.isSubscriptionLossMessage)(msg)) {
-            const subject = this.subjectManager.findJobSubject(msg.jobId);
-            if (subject) {
-                return subject;
-            }
-        }
-        throw new Error(`Received unknown message: ${msg.name}`);
-    }
-}
-exports.SubscriptionModule = SubscriptionModule;
-SubscriptionModule.defaultObserveOptions = {
-    quality: constants_1.DEFAULT_QUALITY,
-};

package/dist/lib/node/core/subscription/EndpointHandler.js

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EndpointHandler = void 0;
-const fast_json_patch_1 = require("fast-json-patch");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const message_1 = require("../../message");
-const SubscriptionModule_1 = require("../SubscriptionModule");
-const constants_1 = require("../../common/constants");
-class EndpointHandler {
-    constructor(requestModule, subjectManager, logger) {
-        this.resultMapper = (0, operators_1.map)((response) => {
-            if ((0, message_1.isHighLevelUpdate)(response)) {
-                const patchedResponse = this.applyEndpointJsonPatchUpdate(response.jobId, response.data);
-                return { response: patchedResponse, data: patchedResponse.data };
-            }
-            return { response, data: response.data };
-        });
-        this.requestToJobMapper = new Map();
-        this.requestModule = requestModule;
-        this.subjectManager = subjectManager;
-        this.responses = {};
-        this.logger = logger;
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    observe(method, path, data, options, requestOptions) {
-        this.validateOptions(options);
-        const subject = new rxjs_1.Subject();
-        const mainSubject = new rxjs_1.ReplaySubject(1);
-        const mainObservable = mainSubject.pipe((0, operators_1.switchAll)());
-        const observable = subject.asObservable().pipe(EndpointHandler.highLevelResponseFilter, this.resultMapper.bind(this));
-        this.requestModule
-            .requestEndpoint(method, path, data, { ...requestOptions, subscribe: true })
-            .then((result) => {
-            this.subjectManager.registerJobSubject(result.response.jobId, subject);
-            this.registerEndpointRequest(result.response.jobId, mainSubject, mainObservable, method, path, data, options);
-            this.registerEndpointResponse(result.response.jobId, result.response);
-            observable.idJob = result.response.jobId;
-            mainSubject.next(observable.pipe((0, operators_1.shareReplay)(1)));
-            mainObservable.idJob = result.response.jobId;
-            subject.next(result.response);
-        })
-            .catch((err) => {
-            this.logger.warn('Subscription request failed.', err);
-            mainSubject.error(err);
-        });
-        return mainObservable;
-    }
-    async unobserve(idJob) {
-        if (!this.subjectManager.hasJobSubject(idJob)) {
-            this.logger.warn(`Could not find subscription for idJob "${idJob}".`);
-            return;
-        }
-        await this.requestModule.request(new message_1.CancelSubscriptionRequest(idJob));
-        this.requestToJobMapper.delete(idJob.toString());
-        this.subjectManager.removeJobSubject(idJob);
-    }
-    findSubject(idJob) {
-        return this.subjectManager.getJobSubject(idJob);
-    }
-    registerEndpointResponse(idJob, response) {
-        this.responses[idJob] = response;
-    }
-    registerEndpointRequest(idJob, subject, observable, method, path, data, options, requestOptions) {
-        this.requestToJobMapper.set(idJob.toString(), { path, subject, observable, data, method, options, requestOptions });
-    }
-    applyEndpointJsonPatchUpdate(idJob, patch) {
-        const response = this.responses[idJob];
-        const result = (0, fast_json_patch_1.applyPatch)(response, patch).newDocument;
-        this.responses[idJob] = result;
-        return result;
-    }
-    restartSubscriptions() {
-        const oldSubscriptions = Array.from(this.subjectManager.jobs.keys());
-        const oldRequests = new Map(this.requestToJobMapper);
-        this.requestToJobMapper.clear();
-        this.subjectManager.jobs.clear();
-        oldSubscriptions.forEach((idJob) => {
-            const request = oldRequests.get(idJob);
-            if (request) {
-                this.resubscribe(request);
-            }
-        });
-    }
-    restartSubscription(jobId) {
-        const oldRequests = new Map(this.requestToJobMapper);
-        this.requestToJobMapper.clear();
-        if (jobId) {
-            const request = oldRequests.get(jobId.toString());
-            if (request) {
-                setTimeout(() => {
-                    this.resubscribe(request);
-                }, constants_1.DEFAULT_RESUBSCRIBE_WAIT_TIME_IN_MS);
-            }
-        }
-    }
-    resubscribe(request) {
-        this.validateOptions(request.options);
-        const subject = new rxjs_1.Subject();
-        const observable = subject.asObservable().pipe(EndpointHandler.highLevelResponseFilter, this.resultMapper.bind(this));
-        this.requestModule
-            .requestEndpoint(request.method, request.path, request.data, { ...request.requestOptions, subscribe: true })
-            .then((result) => {
-            this.subjectManager.registerJobSubject(result.response.jobId, subject);
-            this.registerEndpointResponse(result.response.jobId, result.response);
-            request.observable.idJob = result.response.jobId;
-            request.subject.next(observable.pipe((0, operators_1.shareReplay)(1)));
-            subject.next(result.response);
-            this.registerEndpointRequest(result.response.jobId, request.subject, request.observable, request.method, request.path, request.data, request.options, request.requestOptions);
-        })
-            .catch((err) => {
-            this.logger.warn('Request failed during initial request for restarting endpoint subscription', err);
-        });
-    }
-    validateOptions(options) {
-        const opts = { ...SubscriptionModule_1.SubscriptionModule.defaultObserveOptions, ...options };
-        if (opts.minInterval) {
-            this.logger.warn('Option `minInterval` is deprecated. Use _subscriptionMinimumInterval (GET) or meta.subscription.minimumInterval (POST) for server side throttling.');
-        }
-    }
-}
-exports.EndpointHandler = EndpointHandler;
-EndpointHandler.highLevelResponseFilter = (0, operators_1.filter)((response) => (0, message_1.isHighLevelResponse)(response) || (0, message_1.isHighLevelUpdate)(response));