redis-smq
Version:
A high-performance, reliable, and scalable message queue for Node.js.
219 lines • 10.6 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.MessageManager = void 0;
const redis_smq_common_1 = require("redis-smq-common");
const configuration_js_1 = require("../config-manager/configuration.js");
const _delete_message_js_1 = require("./_/_delete-message.js");
const _get_message_state_js_1 = require("./_/_get-message-state.js");
const _get_message_status_js_1 = require("./_/_get-message-status.js");
const _get_message_js_1 = require("./_/_get-message.js");
const _requeue_message_js_1 = require("./_/_requeue-message.js");
const with_shared_pool_connection_js_1 = require("../common/redis/redis-connection-pool/with-shared-pool-connection.js");
const redis_keys_js_1 = require("../common/redis/redis-keys/redis-keys.js");
const index_js_1 = require("../errors/index.js");
class MessageManager {
constructor() {
const config = configuration_js_1.Configuration.getConfig();
this.logger = (0, redis_smq_common_1.createLogger)(config.logger, this.constructor.name);
}
getMessageStatus(messageId, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Getting message status', { messageId });
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
(0, _get_message_status_js_1._getMessageStatus)(client, messageId, (err, status) => {
if (err) {
this.logger.error('Failed to get message status', {
messageId,
error: err.message,
});
cb(err);
}
else {
this.logger.debug('Successfully retrieved message status', {
messageId,
status,
});
cb(null, status);
}
});
}, callback);
});
}
getMessageState(messageId, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Getting message state', { messageId });
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
(0, _get_message_state_js_1._getMessageState)(client, messageId, (err, state) => {
if (err) {
this.logger.error('Failed to get message state', {
messageId,
error: err.message,
});
cb(err);
}
else {
this.logger.debug('Successfully retrieved message state', {
messageId,
});
cb(null, state === null || state === void 0 ? void 0 : state.toJSON());
}
});
}, callback);
});
}
getMessagesByIds(messageIds, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Getting messages by IDs', {
messageCount: messageIds.length,
});
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
(0, _get_message_js_1._getMessages)(client, messageIds, (err, reply) => {
if (err) {
this.logger.error('Failed to get messages', { error: err.message });
cb(err);
}
else if (!reply) {
this.logger.error('Empty messages reply');
cb(new redis_smq_common_1.CallbackEmptyReplyError());
}
else {
this.logger.debug('Successfully retrieved messages', {
messageCount: reply.length,
});
cb(null, reply.map((i) => i.transfer()));
}
});
}, callback);
});
}
getMessageById(messageId, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Getting message by ID', { messageId });
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
(0, _get_message_js_1._getMessage)(client, messageId, (err, reply) => {
if (err) {
this.logger.error('Failed to get message', {
messageId,
error: err.message,
});
cb(err);
}
else if (!reply) {
this.logger.error('Empty message reply', { messageId });
cb(new redis_smq_common_1.CallbackEmptyReplyError());
}
else {
this.logger.debug('Successfully retrieved message', { messageId });
cb(null, reply.transfer());
}
});
}, callback);
});
}
deleteMessagesByIds(ids, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug(`Deleting ${ids.length} messages by IDs`, {
messageIds: ids,
});
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
redis_smq_common_1.async.withCallback((cb) => (0, _delete_message_js_1._deleteMessage)(client, ids, null, cb), (reply, cb) => {
this.logger.debug('MessageList deletion completed', reply);
cb(null, reply);
}, cb);
}, (err, result) => {
if (err) {
this.logger.error('Failed to delete messages by IDs', {
error: err.message,
messageIds: ids,
});
}
callback(err, result);
});
});
}
deleteMessageById(id, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Deleting message by ID', { messageId: id });
this.deleteMessagesByIds([id], (err, reply) => {
if (err) {
this.logger.error('Failed to delete message', {
messageId: id,
error: err.message,
});
callback(err);
}
else {
this.logger.debug('Successfully deleted message', { messageId: id });
callback(null, reply);
}
});
});
}
requeueMessageById(messageId, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Requeuing message by ID', { messageId });
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
(0, _requeue_message_js_1._requeueMessage)(client, messageId, (err, newMessageId) => {
if (err) {
this.logger.error('Failed to requeue message', {
messageId,
error: err.message,
});
return cb(err);
}
if (!newMessageId)
return cb(new redis_smq_common_1.CallbackEmptyReplyError());
this.logger.debug(`Successfully requeued message ${messageId}. New message ID is ${newMessageId}`);
cb(null, newMessageId);
});
}, callback);
});
}
getMessageUnacknowledgementHistory(messageId, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Getting message unacknowledgement history', messageId);
if (!configuration_js_1.Configuration.getConfig().messageAudit.unacknowledgementHistory.enabled) {
this.logger.debug('Message unacknowledgement history is disabled');
return callback(new index_js_1.UnacknowledgmentHistoryDisabledError());
}
const { keyMessage, keyMessageUnacknowledgementHistory } = redis_keys_js_1.redisKeys.getMessageKeys(messageId);
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, done) => {
redis_smq_common_1.async.waterfall([
(cb) => {
client.exists(keyMessage, (err, exists) => {
if (err) {
this.logger.error('Failed to check message existence', {
messageId,
error: err.message,
});
return cb(err);
}
if (!exists)
return cb(new index_js_1.MessageNotFoundError());
cb();
});
},
(_, cb) => {
client.lrange(keyMessageUnacknowledgementHistory, 0, -1, (err, records) => {
if (err) {
this.logger.error('Failed to get message history', {
messageId,
error: err.message,
});
return cb(err);
}
const history = (records === null || records === void 0 ? void 0 : records.map((record) => JSON.parse(record))) || [];
this.logger.debug('Successfully retrieved message history', {
messageId,
recordCount: history.length,
});
cb(null, history);
});
},
], done);
}, callback);
});
}
}
exports.MessageManager = MessageManager;
//# sourceMappingURL=message-manager.js.map