@glue42/bbg-market-data
Version:
A high-level API that wraps existing Glue42 Bloomberg Bridge Market Data interop methods. The API is based on the jBloomberg open source wrapper.
197 lines (196 loc) • 9.14 kB
JavaScript
import { __assign, __awaiter, __extends, __generator, __rest } from "tslib";
import { PromiseWrapper } from "../promise-wrapper";
import { RequestStatus } from "../request-status";
import { isEventOfType, isPending } from "./helpers";
import { EventTypes } from "./event-types";
import { callSafe, extractErrorMessage } from "./../utils";
import { BaseRequest } from "./base-request";
import { requestFailureHandler, serviceOpenedFailureHandler, sessionStartUpFailureHandler, sessionTerminatedHandler } from "./message-handlers";
var DATA_EVENT = "data-event";
var ERROR_EVENT = "error-event";
var STATUS_EVENT = "status-event";
var NonSubscriptionRequestImpl = (function (_super) {
__extends(NonSubscriptionRequestImpl, _super);
function NonSubscriptionRequestImpl(sessionManager, config, operationArgs, handlers) {
var _this = _super.call(this, sessionManager, config, operationArgs) || this;
_this.sessionManager = sessionManager;
_this.config = config;
_this.operationArgs = operationArgs;
_this.handlers = handlers;
_this.aggregatedResponseData = [];
_this.shouldAggregateResponse = true;
_super.prototype.onRequestStatusChanged.call(_this, _this.handleRequestStatusChanged.bind(_this));
if (typeof _this.handlers.partialResponseData != "function" ||
typeof _this.handlers.responseData != "function" ||
typeof _this.handlers.responseError != "function") {
throw new Error("All handlers must be functions.");
}
return _this;
}
Object.defineProperty(NonSubscriptionRequestImpl.prototype, "api", {
get: function () {
var that = this;
return {
get id() {
return that.requestId;
},
get settings() {
return {
operation: that.config.operation,
service: that.config.service,
aggregateResponse: that.shouldAggregateResponse,
operationArgs: that.operationArgs,
};
},
get status() {
return that._status;
},
open: this.open.bind(that),
close: that.closeRequest.bind(that),
onData: function (callback) {
return that.registry.add(DATA_EVENT, callback);
},
onError: function (callback) {
return that.registry.add(ERROR_EVENT, callback);
},
onEvent: that.onEvent.bind(that),
onStatus: function (callback) {
callSafe(callback, that._status);
return that.registry.add(STATUS_EVENT, callback);
},
};
},
enumerable: false,
configurable: true
});
NonSubscriptionRequestImpl.prototype.open = function (options) {
return __awaiter(this, void 0, void 0, function () {
var _a, aggregateResponse, otherOptions;
return __generator(this, function (_b) {
if (isPending(this._status)) {
return [2, Promise.reject(new Error("Request can be opened/reopened if its status is Created, Failed, Closed or Completed. Either close the request or wait it to complete."))];
}
this.reset();
_a = options !== null && options !== void 0 ? options : {}, aggregateResponse = _a.aggregateResponse, otherOptions = __rest(_a, ["aggregateResponse"]);
this.shouldAggregateResponse = aggregateResponse === false ? false : true;
this.aggregatedResponsePW = new PromiseWrapper();
_super.prototype.openRequest.call(this, __assign(__assign({}, otherOptions), { messageProcessor: this.messageProcessor.bind(this) })).catch(function () {
});
return [2, this.aggregatedResponsePW.promise];
});
});
};
NonSubscriptionRequestImpl.prototype.handleRequestStatusChanged = function (event) {
var _a, _b, _c;
this.registry.execute(STATUS_EVENT, event.status);
if (event.status === RequestStatus.Active) {
if (this.shouldAggregateResponse === false) {
(_a = this.aggregatedResponsePW) === null || _a === void 0 ? void 0 : _a.resolve(undefined);
}
return;
}
if (event.status === RequestStatus.Closed || event.status === RequestStatus.Completed) {
return (_b = this.aggregatedResponsePW) === null || _b === void 0 ? void 0 : _b.resolve(this.aggregatedResponseData);
}
if (event.status === RequestStatus.Failed) {
this.registry.execute(ERROR_EVENT, event.error);
return (_c = this.aggregatedResponsePW) === null || _c === void 0 ? void 0 : _c.reject(event.error);
}
};
NonSubscriptionRequestImpl.prototype.messageProcessor = function (eventMessage) {
return __awaiter(this, void 0, void 0, function () {
var error;
return __generator(this, function (_a) {
error = [
sessionStartUpFailureHandler(eventMessage),
sessionTerminatedHandler(eventMessage),
serviceOpenedFailureHandler(eventMessage),
requestFailureHandler(eventMessage),
].find(function (_a) {
var match = _a.match;
return match;
});
if (error) {
return [2, { action: "fail", error: error.data }];
}
if (isEventOfType(eventMessage, EventTypes.Response)) {
return [2, this.processResponseBBGEvent(eventMessage)];
}
if (isEventOfType(eventMessage, EventTypes.PartialResponse)) {
this.processPartialResponseBBGEvent(eventMessage);
}
return [2, Promise.resolve({ action: 'continue' })];
});
});
};
NonSubscriptionRequestImpl.prototype.processPartialResponseBBGEvent = function (eventMessage) {
var _a;
try {
var _b = this.handlers.partialResponseData(eventMessage), data = _b.data, match = _b.match;
if (!match) {
return;
}
if (this.shouldAggregateResponse) {
(_a = this.aggregatedResponseData) === null || _a === void 0 ? void 0 : _a.push(data);
}
this.raiseResponseData({
data: data,
isLast: false,
});
}
catch (_c) {
this.raiseResponseData({
data: undefined,
isLast: false,
});
}
};
NonSubscriptionRequestImpl.prototype.processResponseBBGEvent = function (eventMessage) {
var _a;
try {
var responseDataResult = this.handlers.responseData(eventMessage);
if (responseDataResult.match) {
if (this.shouldAggregateResponse) {
(_a = this.aggregatedResponseData) === null || _a === void 0 ? void 0 : _a.push(responseDataResult.data);
}
this.raiseResponseData({
data: responseDataResult.data,
isLast: true,
});
return { action: 'complete' };
}
var responseErrorResult = this.handlers.responseError(eventMessage);
if (responseErrorResult.match) {
return {
action: 'fail',
error: responseErrorResult.data
};
}
return {
action: 'fail',
error: new Error("Received a " + EventTypes.Response + " event but neither data nor error messages can be matched. Check handlers.")
};
}
catch (error) {
var errorMsg = extractErrorMessage(error);
return {
action: 'fail',
error: new Error("Processing " + EventTypes.Response + " event message errored with \"" + errorMsg + "\"")
};
}
};
NonSubscriptionRequestImpl.prototype.raiseResponseData = function (responseData) {
this.registry.execute(DATA_EVENT, responseData);
};
NonSubscriptionRequestImpl.prototype.reset = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
this.shouldAggregateResponse = true;
this.aggregatedResponseData = [];
return [2];
});
});
};
return NonSubscriptionRequestImpl;
}(BaseRequest));
export { NonSubscriptionRequestImpl };