nodejs-event-manager
Version:
A nodeJS Event Manager to emit, and listen event through nodeJS
166 lines • 7.52 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const uuid_1 = require("uuid");
const defaultOptions_1 = require("./lib/defaultOptions");
const EventManagerError_1 = require("./lib/EventManagerError");
const helper_1 = require("./lib/helper");
const logger_1 = require("./lib/logger");
const Emittery = require("emittery");
class EventManager {
constructor(options) {
this.options = Object.assign({}, defaultOptions_1.defaultOptions, options);
this.emittery = new Emittery();
this.createLogger();
}
createLogger() {
logger_1.createLogger({
prefix: this.options.logPrefix,
level: this.options.logLevel,
transportMode: this.options.logTransportMode
});
}
on(eventName, listener) {
return __awaiter(this, void 0, void 0, function* () {
try {
logger_1.LOGGER.debug(`Listening ${eventName} Event ...`);
this.emittery.on(eventName, (payload) => __awaiter(this, void 0, void 0, function* () {
try {
const response = yield listener(payload);
if (response) {
this.emitResponseIfNeeded(payload, response);
}
return response;
}
catch (error) {
logger_1.LOGGER.error(`Error in listener for event ${eventName}`, error);
}
}));
}
catch (e) {
logger_1.LOGGER.error(`Unable to listen event ${eventName}`, e);
throw new EventManagerError_1.EventManagerError(`Unable to listen event ${eventName}`, e);
}
});
}
emit(eventName, payload) {
return __awaiter(this, void 0, void 0, function* () {
try {
logger_1.LOGGER.debug(`Emitting ${eventName} Message ...`);
// we should create the metas information here
payload = this.addMetasToPayload(payload, eventName);
this.emittery.emit(eventName, payload);
logger_1.LOGGER.debug(`Message ${eventName} Emitted`);
return payload;
}
catch (err) {
throw new EventManagerError_1.EventManagerError(`Unable to emit event ${eventName}`, err);
}
});
}
emitAndWait(eventName, payload, replyToName, options) {
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
logger_1.LOGGER.info(`EmitAndWait : ${eventName}`);
let replyTo = replyToName
? replyToName
: `${eventName}${this.options.defaultResponseSuffix}`;
const correlationId = uuid_1.v4();
replyTo += `.${correlationId}`;
const overrideMetas = payload._metas
? Object.assign({ correlationId,
replyTo }, payload._metas) : {
correlationId,
replyTo
};
const newPayload = Object.assign({}, payload);
newPayload._metas = overrideMetas;
const listen = () => {
return new Promise(resolve => {
this.on(replyTo, (responsePayload) => {
resolve(responsePayload);
});
});
};
const duration = options && options.emitAndWaitTimeout
? options.emitAndWaitTimeout
: this.options.emitAndWaitTimeout;
const timeoutMessage = `Timeout Error after ${duration} milliseconds for event ${eventName} and correlationId ${correlationId} `;
Promise.race([helper_1.timeout(duration, timeoutMessage), listen()])
.then((payload) => {
resolve(payload);
// cleaning
// Putting in setTimeout to be done after every thing else;
setImmediate(() => __awaiter(this, void 0, void 0, function* () {
this.emittery.off(replyTo, (payload) => {
console.log("e");
});
}));
})
.catch(reject);
const payloadEmitted = yield this.emit(eventName, newPayload);
logger_1.LOGGER.info(`EmitAndWait : ${eventName}`, { payload: payloadEmitted });
}));
});
}
initialize() {
return __awaiter(this, void 0, void 0, function* () {
return;
});
}
close() {
return __awaiter(this, void 0, void 0, function* () {
logger_1.LOGGER.debug(`Disconnect EventManager`, Object.assign({}, this.options));
return this.emittery.clearListeners();
});
}
reset() {
return __awaiter(this, void 0, void 0, function* () {
logger_1.LOGGER.debug(`Reset EventManager listeners`, Object.assign({}, this.options));
return this.emittery.clearListeners();
});
}
addMetasToPayload(payload, eventName) {
if (!this.options.metas) {
return payload;
}
else {
const metasOverride = payload._metas ? payload._metas : {};
const metas = Object.assign({ guid: uuid_1.v4(), name: eventName, application: this.options.application, timestamp: Date.now() }, metasOverride);
if (isOverrideMetasFunction(this.options.metas)) {
return Object.assign({}, payload, { _metas: this.options.metas(metas) });
}
else {
return Object.assign({}, payload, { _metas: metas });
}
}
}
emitResponseIfNeeded(sourcePayload, targetPayload) {
return __awaiter(this, void 0, void 0, function* () {
if (sourcePayload &&
sourcePayload._metas &&
sourcePayload._metas.correlationId &&
sourcePayload._metas.replyTo &&
targetPayload !== null &&
typeof targetPayload === "object") {
const newPayload = Object.assign({ _metas: {
responseTo: sourcePayload._metas.name,
correlationId: sourcePayload._metas.correlationId
} }, targetPayload);
return this.emit(sourcePayload._metas.replyTo, newPayload);
}
});
}
}
exports.EventManager = EventManager;
function isOverrideMetasFunction(func) {
return {}.toString.call(func) === "[object Function]";
}
//# sourceMappingURL=EventManager.class.js.map