legend-transactional 2.3.2 → 2.3.3

package/dist/index.d.mts

@@ -52,6 +52,10 @@ declare const availableMicroservices: {
      * Represents the "room-snapshot" microservice.
      */
     readonly RoomSnapshot: "room-snapshot";
+    /**
+     * Represents the "transactional" microservice.
+     */
+    readonly Transactional: "transactional";
     /**
      * Represents the "legend-send-email" microservice.
      */
@@ -466,14 +470,39 @@ interface EventPayload {
         bucketName: string;
         filePaths: string[];
     };
+    /**
+     * Emitted when an event is published by a microservice (audit tracking)
+     */
+    'audit.published': {
+        /**
+         * The microservice that published the event
+         */
+        publisher_microservice: string;
+        /**
+         * The event that was published
+         */
+        published_event: string;
+        /**
+         * Timestamp when the event was published (UNIX timestamp in seconds)
+         */
+        published_at: number;
+        /**
+         * UUID v7 unique identifier for cross-event tracking
+         */
+        event_id: string;
+    };
     /**
      * Emitted when an event is received by a microservice before processing starts (audit tracking)
      */
     'audit.received': {
+        /**
+         * The microservice that published the original event
+         */
+        publisher_microservice: string;
         /**
          * The microservice that received the event
          */
-        microservice: string;
+        receiver_microservice: string;
         /**
          * The event that was received
          */
@@ -487,18 +516,22 @@ interface EventPayload {
          */
         queue_name: string;
         /**
-         * Optional event identifier for tracking
+         * UUID v7 from message properties for cross-event tracking
          */
-        event_id?: string;
+        event_id: string;
     };
     /**
      * Emitted when an event is successfully processed by a microservice for audit tracking
      */
     'audit.processed': {
+        /**
+         * The microservice that published the original event
+         */
+        publisher_microservice: string;
         /**
          * The microservice that processed the event
          */
-        microservice: string;
+        processor_microservice: string;
         /**
          * The original event that was processed
          */
@@ -512,18 +545,22 @@ interface EventPayload {
          */
         queue_name: string;
         /**
-         * Optional event identifier for tracking
+         * UUID v7 from message properties for cross-event tracking
          */
-        event_id?: string;
+        event_id: string;
     };
     /**
      * Emitted when a message is rejected/nacked and sent to dead letter queue
      */
     'audit.dead_letter': {
+        /**
+         * The microservice that published the original event
+         */
+        publisher_microservice: string;
         /**
          * The microservice that rejected the event
          */
-        microservice: string;
+        rejector_microservice: string;
         /**
          * The original event that was rejected
          */
@@ -545,9 +582,9 @@ interface EventPayload {
          */
         retry_count?: number;
         /**
-         * Optional event identifier for tracking
+         * UUID v7 from message properties for cross-event tracking
          */
-        event_id?: string;
+        event_id: string;
     };
 }
 /**
@@ -556,6 +593,7 @@ interface EventPayload {
 declare const microserviceEvent: {
     readonly 'TEST.IMAGE': "test.image";
     readonly 'TEST.MINT': "test.mint";
+    readonly 'AUDIT.PUBLISHED': "audit.published";
     readonly 'AUDIT.RECEIVED': "audit.received";
     readonly 'AUDIT.PROCESSED': "audit.processed";
     readonly 'AUDIT.DEAD_LETTER': "audit.dead_letter";
@@ -694,21 +732,31 @@ declare class EventsConsumeChannel extends ConsumeChannel {
     /**
      * The microservice name that is processing the event
      */
-    private readonly microservice;
+    private readonly processorMicroservice;
     /**
      * The original event that was received
      */
     private readonly processedEvent;
+    /**
+     * The unique event identifier (messageId) for tracking across audit events
+     */
+    private readonly eventId;
+    /**
+     * The microservice that originally published the event
+     */
+    private readonly publisherMicroservice;
     /**
      * Creates a new EventsConsumeChannel instance
      *
      * @param channel - The AMQP Channel
      * @param msg - The consumed message
      * @param queueName - The queue name
-     * @param microservice - The microservice name processing the event
+     * @param processorMicroservice - The microservice name processing the event
      * @param processedEvent - The event type being processed
+     * @param eventId - Unique event identifier (messageId) for audit tracking
+     * @param publisherMicroservice - The microservice that originally published the event
      */
-    constructor(channel: Channel, msg: ConsumeMessage, queueName: string, microservice: string, processedEvent: string);
+    constructor(channel: Channel, msg: ConsumeMessage, queueName: string, processorMicroservice: string, processedEvent: string, eventId: string, publisherMicroservice: string);
     /**
      * Acknowledges the consumed saga event/command.
      * Automatically emits audit.processed event after successful ACK.
@@ -753,6 +801,7 @@ declare const queue: {
      * Audit queue names for separate audit event types
      * @constant
      */
+    readonly AuditPublished: "audit_published_commands";
     readonly AuditReceived: "audit_received_commands";
     readonly AuditProcessed: "audit_processed_commands";
     readonly AuditDeadLetter: "audit_dead_letter_commands";
@@ -1035,6 +1084,15 @@ declare const rankingsCommands: {};
  */
 type RankingsCommands = (typeof rankingsCommands)[keyof typeof rankingsCommands];
 
+/**
+ * Different commands related to the "transactional" microservice.
+ */
+declare const transactionalCommands: {};
+/**
+ * Available commands for the "transactional" microservice.
+ */
+type TransactionalCommands = (typeof transactionalCommands)[keyof typeof transactionalCommands];
+
 /**
  * A map that defines the relationship between microservices and their corresponding commands.
  */
@@ -1109,6 +1167,10 @@ interface CommandMap {
      * Represents the mapping of "legend-storage" microservice commands.
      */
     [availableMicroservices.Storage]: StorageCommands;
+    /**
+     * Represents the mapping of "transactional" microservice commands.
+     */
+    [availableMicroservices.Transactional]: TransactionalCommands;
 }
 /**
  * Represents a command specific to a microservice.
@@ -1591,16 +1653,11 @@ declare const getConsumeChannel: () => Promise<Channel>;
  */
 declare const closeConsumeChannel: () => Promise<void>;
 
-/**
- * Save the RabbitMQ URI for establishing a connection.
- *
- * @param {string} uri - The RabbitMQ URI to save.
- */
-declare const saveUri: (uri: string) => void;
+declare const getStoredConfig: () => TransactionalConfig<AvailableMicroservices, MicroserviceEvent>;
 /**
  * Get the RabbitMQ connection or establish a new connection if not already connected.
  *
- * @returns {Promise<Connection>} A promise that resolves to the RabbitMQ connection.
+ * @returns {Promise<ChannelModel>} A promise that resolves to the RabbitMQ connection.
  */
 declare const getRabbitMQConn: () => Promise<ChannelModel>;
 /**
@@ -1619,82 +1676,6 @@ declare const saveQueueForHealthCheck: (queue: string) => void;
  * @returns {Promise<boolean>} A promise that resolves to `true` if the connection is healthy and the queue exists, or `false` otherwise.
  */
 declare const isConnectionHealthy: () => Promise<boolean>;
-
-/**
- * Start a global saga listener to handle incoming saga events/commands from all microservices.
- *
- * @param {string} url - The RabbitMQ URL to establish a connection.
- *
- * @returns {Promise<Emitter>} Emitter<ConsumerSagaEvents<T>> - A promise that resolves to an emitter
- * for handling the saga events emitted by the specified microservice.
- * @throws {Error} If the RabbitMQ URI is not initialized or there is an issue with the connection.
- *
- * @template T
- * @example
- * await prepare('amqp://localhost');
- * const sagaEmitter = await startGlobalSagaListener<AvailableMicroservices>();
- * // Also valid and equivalent to the above
- * const g = await startGlobalSagaListener();
- *
- * // Listen to a single microservice saga event
- * g.on(MintCommands.MintImage, async ({ channel, step }) => {
- *      // ... do something, ack or nack the message
- * });
- *
- * // Listen to all microservice saga events, take notice that the event already listen above it needs to be ignored here.
- * g.on('*', async (command, { step, channel }) => {
- *     if (command === MintCommands.MintImage) {
- *         // Ignore the event already listened above
- *         return;
- *     }
- *     // ... do something ack or nack if there are commands that are not handled
- * });
- *
- * // When not needed anymore, you can close the RabbitMQ connection
- * await stopRabbitMQ();
- * @see stopRabbitMQ
- * @see prepare
- * @see startSaga
- * @see connectToSagaCommandEmitter
- * @see commenceSagaListener
- */
-declare const startGlobalSagaStepListener: <T extends AvailableMicroservices>(url: string) => Promise<Emitter<SagaConsumeSagaEvents<T>>>;
-/**
- * Start a saga listener to handle incoming **commence saga events**
- *
- * @param {string} url - The RabbitMQ URL to establish a connection.
- *
- * @returns {Promise<Emitter>} Emitter<ConsumerCommenceSaga<T>> - A promise that resolves to an emitter
- * for handling the saga emitted to commence a saga.
- * @throws {Error} If the RabbitMQ URI is not initialized or there is an issue with the connection.
- *
- * @example
- * await prepare('amqp://localhost');
- * const c = await commenceSagaListener();
- *
- * // Listen to a single saga commence event
- * c.on(sagaTitle.RechargeBalance, async ({ saga, channel }) => {
- *      // ... start the saga
- * });
- *
- * // Listen to all saga events, take notice that the event already listen above it needs to be ignored here.
- * c.on('*', async (sagaTitle, { saga, channel }) => {
- *     if (sagaTitle === sagaTitle.RechargeBalance) {
- *         // Ignore the event already listened above
- *         return;
- *     }
- *     // ... start the sagas
- * });
- *
- * // When not needed anymore, you can close the RabbitMQ connection
- * await stopRabbitMQ();
- * @see stopRabbitMQ
- * @see prepare
- * @see startSaga
- * @see connectToSagaCommandEmitter
- * @see startGlobalSagaStepListener
- */
-declare const commenceSagaListener: <U extends SagaTitle>(url: string) => Promise<Emitter<CommenceSagaEvents<U>>>;
 /**
  * A class to connect to the saga orchestration system and handle incoming saga events/commands.
  * @template T - `AvailableMicroservices` enum.
@@ -1750,80 +1731,6 @@ interface TransactionalConfig<T extends AvailableMicroservices, U extends Micros
     microservice: T;
     events: U[];
 }
-/**
- * Connects to a specific microservice's saga command emitter to handle incoming saga events/commands.
- *
- * @param [config] - Configuration for receiving saga commands to a specific microservice and handle incoming saga commands.
- * @returns {Promise<Emitter>} Emitter<MicroserviceConsumeSagaEvents<T>> - A promise that resolves to an emitter for handling the saga commands
- * emitted to a specified microservice.
- * @throws {Error} If the RabbitMQ URI is not initialized or there is an issue with the connection.
- *
- * @template T - The specific microservice to connect to (e.g., 'image', 'payment'). Must be one of the types defined in the `AvailableMicroservices` enum.
- *
- * @example
- * // Establish a connection and connect to the 'image' microservice's saga command emitter
- * await prepare('amqp://localhost');
- * const e = await connectToSagaCommandEmitter(AvailableMicroservices.Image);
- *
- * // Listen for 'image' microservice saga events/commands
- * e.on(ImageCommands.CreateImage, async ({ channel, sagaId, payload }) => {
- *   // Handle the 'create_image' saga event/command for the 'image' microservice, ack or nack the message
- * });
- *
- * // Listen to all commands/events emitted by the 'image' microservice or use a global pattern, take notice that the events already listen above it needs to be ignored here.
- * e.on('*', async (command, { channel, sagaId, payload }) => {
- *    if (command === ImageCommands.CreateImage) {
- *    // Ignore the event already listened above
- *    return;
- *    }
- *    // ... do something ack or nack if there are commands that are not handled
- * });
- *
- * // When not needed anymore, you can close the RabbitMQ connection
- * await stopRabbitMQ();
- * @see stopRabbitMQ
- * @see startTransactional
- */
-declare const connectToSagaCommandEmitter: <T extends AvailableMicroservices>(config: TransactionalConfig<T, MicroserviceEvent>) => Promise<Emitter<MicroserviceConsumeSagaEvents<T>>>;
-/**
- * Connects to specific events emitted by a particular microservice.
- *
- * This allows you to listen for and handle specific events of interest, filtering out other events the microservice might emit.
- *
- * @template T - The specific microservice to connect to (e.g., 'image', 'payment'). Must be one of the types defined in the `AvailableMicroservices` enum.
- * @template U - The type of event to listen for. Must be one of the types defined in the `MicroserviceEvent` enum.
- *
- * @param {TransactionalConfig<T, U>} config - Configuration for receiving saga commands to a specific microservice and handle incoming subscription events.
- * @returns {Promise<Emitter>} Emitter<MicroserviceConsumeEvents<U>> - A promise that resolves to an emitter, providing a way to listen to the specified events.
- * @async
- *
- * @example
- * const url = 'amqp://localhost';
- * await prepare(url);
- * // Connect to the 'image' microservice and listen for 'ImageCreated' and 'ImageDeleted' events
- * const emitter = await connectToEvents(AvailableMicroservices.Image, [MicroserviceEvent.ImageCreated, MicroserviceEvent.ImageDeleted]);
- *
- * // Handle 'ImageCreated' events
- * emitter.on(MicroserviceEvent.ImageCreated, ({ channel, payload }) => {
- *   // Process the image creation payload
- * });
- *
- * // Handle 'ImageDeleted' events
- * emitter.on(MicroserviceEvent.ImageDeleted, ({ channel, payload }) => {
- *   // Process the image deletion payload
- * });
- *
- * // When not needed anymore, you can close the RabbitMQ connection
- * await stopRabbitMQ();
- *
- * @see stopRabbitMQ
- * @see prepare
- * @see connectToSagaCommandEmitter
- * @see startTransactional
- * @see AvailableMicroservices
- * @see MicroserviceEvent
- */
-declare const connectToEvents: <T extends AvailableMicroservices, U extends MicroserviceEvent>(config: TransactionalConfig<T, U>) => Promise<Emitter<MicroserviceConsumeEvents<U>>>;
 /**
  * A class to connect to a specific microservice's saga command emitter and handle incoming saga events/commands.
  * @template T - The specific microservice to connect to (e.g., 'image', 'payment'). Must be one of the types defined in the `AvailableMicroservices` enum.
@@ -1943,4 +1850,4 @@ declare const getEventObject: (event: MicroserviceEvent) => {
  */
 declare function extractMicroserviceFromQueue(queueName: string): string;
 
-export { type AuditEdaCommands, type AuthCommands, type AvailableMicroservices, type BlockchainCommands, type CoinsCommands, type CommandMap, type CommenceSaga, type CommenceSagaEvents, type CommenceSagaHandler, type CompletedRanking, type EventPayload, EventsConsumeChannel, type EventsHandler, type Exchange, type Gender, MAX_NACK_RETRIES, MAX_OCCURRENCE, type MicroserviceCommand, MicroserviceConsumeChannel, type MicroserviceConsumeEvents, type MicroserviceConsumeSagaEvents, type MicroserviceEvent, type MicroserviceHandler, NACKING_DELAY_MS, type Nack, type PaymentEmailType, PaymentEmailTypes, type QueueConsumerProps, type RankingWinners, type RankingsCommands, type RapidMessagingCommands, type Room, type RoomCreatorCommands, type RoomInventoryCommands, type RoomSnapshotCommands, type RoomType, RoomTypes, Saga, SagaCommenceConsumeChannel, type SagaCommencePayload, SagaConsumeChannel, type SagaConsumeSagaEvents, type SagaHandler, type SagaStep, type SagaStepDefaults, type SagaTitle, type SendEmailCommands, type ShowcaseCommands, type SocialCommands, type SocialMediaRoomsCommands, type SocialUser, type Status, type StorageCommands, type TestImageCommands, type TestMintCommands, Transactional, type TransactionalConfig, type UserLocation, auditEdaCommands, authCommands, availableMicroservices, blockchainCommands, closeConsumeChannel, closeRabbitMQConn, closeSendChannel, coinsCommands, commenceSaga, commenceSagaConsumeCallback, commenceSagaListener, connectToEvents, connectToSagaCommandEmitter, consume, createAuditLoggingResources, createConsumers, createHeaderConsumers, eventCallback, exchange, extractMicroserviceFromQueue, fibonacci, gender, getConsumeChannel, getEventKey, getEventObject, getQueueConsumer, getQueueName, getRabbitMQConn, getSendChannel, isConnectionHealthy, microserviceEvent, nodeDataDefaults, publishEvent, queue, rankingsCommands, rapidMessagingCommands, roomCreatorCommands, roomInventoryCommands, roomSnapshotCommands, sagaConsumeCallback, sagaStepCallback, sagaTitle, saveQueueForHealthCheck, saveUri, sendEmailCommands, sendToQueue, showcaseCommands, socialCommands, socialMediaRoomsCommands, startGlobalSagaStepListener, status, stopRabbitMQ, storageCommands, testImageCommands, testMintCommands };
+export { type AuditEdaCommands, type AuthCommands, type AvailableMicroservices, type BlockchainCommands, type CoinsCommands, type CommandMap, type CommenceSaga, type CommenceSagaEvents, type CommenceSagaHandler, type CompletedRanking, type EventPayload, EventsConsumeChannel, type EventsHandler, type Exchange, type Gender, MAX_NACK_RETRIES, MAX_OCCURRENCE, type MicroserviceCommand, MicroserviceConsumeChannel, type MicroserviceConsumeEvents, type MicroserviceConsumeSagaEvents, type MicroserviceEvent, type MicroserviceHandler, NACKING_DELAY_MS, type Nack, type PaymentEmailType, PaymentEmailTypes, type QueueConsumerProps, type RankingWinners, type RankingsCommands, type RapidMessagingCommands, type Room, type RoomCreatorCommands, type RoomInventoryCommands, type RoomSnapshotCommands, type RoomType, RoomTypes, Saga, SagaCommenceConsumeChannel, type SagaCommencePayload, SagaConsumeChannel, type SagaConsumeSagaEvents, type SagaHandler, type SagaStep, type SagaStepDefaults, type SagaTitle, type SendEmailCommands, type ShowcaseCommands, type SocialCommands, type SocialMediaRoomsCommands, type SocialUser, type Status, type StorageCommands, type TestImageCommands, type TestMintCommands, Transactional, type TransactionalCommands, type TransactionalConfig, type UserLocation, auditEdaCommands, authCommands, availableMicroservices, blockchainCommands, closeConsumeChannel, closeRabbitMQConn, closeSendChannel, coinsCommands, commenceSaga, commenceSagaConsumeCallback, consume, createAuditLoggingResources, createConsumers, createHeaderConsumers, eventCallback, exchange, extractMicroserviceFromQueue, fibonacci, gender, getConsumeChannel, getEventKey, getEventObject, getQueueConsumer, getQueueName, getRabbitMQConn, getSendChannel, getStoredConfig, isConnectionHealthy, microserviceEvent, nodeDataDefaults, publishEvent, queue, rankingsCommands, rapidMessagingCommands, roomCreatorCommands, roomInventoryCommands, roomSnapshotCommands, sagaConsumeCallback, sagaStepCallback, sagaTitle, saveQueueForHealthCheck, sendEmailCommands, sendToQueue, showcaseCommands, socialCommands, socialMediaRoomsCommands, status, stopRabbitMQ, storageCommands, testImageCommands, testMintCommands, transactionalCommands };