@jetit/publisher 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetit/publisher",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "type": "commonjs",
   "dependencies": {
     "@jetit/id": "0.0.6",
@@ -12,6 +12,5 @@
     "tslib": "2.5.0"
   },
   "main": "./src/index.js",
-  "types": "./src/index.d.ts",
-  "readme": "README.md"
+  "types": "./src/index.d.ts"
 }

package/src/index.d.ts

@@ -1 +1,2 @@
 export * from './lib/publisher';
+export { EventData } from './lib/redis/types';

package/src/lib/redis/groups.js

@@ -4,7 +4,7 @@ exports.getAllConsumerGroups = void 0;
 const tslib_1 = require("tslib");
 function getAllConsumerGroups(eventName, redisConnection) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const consumerGroups = yield redisConnection.smembers(`consumerGroups:${eventName}`);
+        const consumerGroups = yield redisConnection.smembers(`${eventName}`);
         return consumerGroups;
     });
 }

package/src/lib/redis/streams.d.ts

@@ -1,5 +1,5 @@
 import { RedisType } from './registry';
-import { EventData } from './types';
+import { EventData, PublishData } from './types';
 import { Observable } from 'rxjs';
 export declare class Streams {
     private _redisPublisher?;
@@ -47,7 +47,7 @@ export declare class Streams {
      * const eventData = { eventName: 'order.created', data: orderData };
      * await streams.publish(eventData);
      */
-    publish<T>(data: EventData<T>): Promise<void>;
+    publish<TData = unknown, TName extends string = string>(data: PublishData<TData, TName>): Promise<void>;
     /**
      * Schedules an event to be published at a specified future time. Thee event gets published if the
      * differnece between the current time and the scheduled time is less than 500ms.
@@ -69,7 +69,7 @@ export declare class Streams {
      *
      * await streams.scheduledPublish(futureTime, eventData);
      */
-    scheduledPublish<T>(scheduledTime: Date, eventData: EventData<T>, uniquePerInstance?: boolean): Promise<void>;
+    scheduledPublish<T, const TName extends string = string>(scheduledTime: Date, eventData: EventData<T, TName>, uniquePerInstance?: boolean): Promise<void>;
     /**
      * Listens for events with the given name and returns an Observable that emits an EventData<T> object
      * each time a new event is received.
@@ -97,7 +97,7 @@ export declare class Streams {
      *   console.log('New order created:', event.data);
      * });
      */
-    listen<T>(eventName: string, maxRetries?: number, initialDelay?: number): Observable<EventData<T>>;
+    listen<T = unknown, const TName extends string = string>(eventName: TName, maxRetries?: number, initialDelay?: number): Observable<EventData<T, TName>>;
     private listenInternals;
     /**
      * This method takes all messages allocated to this instance and republishes them so

package/src/lib/redis/streams.js

@@ -44,7 +44,10 @@ class Streams {
         const cleanUpInterval = (_a = parseInt(process.env['CLEANUP_INTERVAL'] || '1000 * 60 * 60', 10)) !== null && _a !== void 0 ? _a : 1000 * 60 * 60;
         this.cleanUpTimer = (0, rxjs_1.interval)(cleanUpInterval).subscribe(() => {
             this.clearDuplicationCheckKeys();
-            this.eventsListened.forEach((eventName) => this.cleanupAcknowledgedMessages(eventName, cleanUpInterval));
+            this.eventsListened.forEach((eventName) => {
+                this.cleanupAcknowledgedMessages(eventName, cleanUpInterval);
+                this.republishUnprocessedEvents(eventName);
+            });
         });
     }
     createConsumerGroup(eventName) {
@@ -85,28 +88,15 @@ class Streams {
             } while (cursor !== '0');
         });
     }
-    /**
-     * Publishes an event with the given data to the Redis event stream.
-     *
-     * The method generates a unique event ID for each event, and adds it to the event data to handle message
-     * deduplication.
-     *
-     * @param data - An EventData<T> object containing the data for the event.
-     *
-     * @returns A Promise that resolves when the event has been published to the Redis stream.
-     *
-     * @example
-     *
-     * // Publish an "order.created" event with the given order data
-     * const orderData = { id: '123', customerName: 'John Doe', amount: 100 };
-     * const eventData = { eventName: 'order.created', data: orderData };
-     * await streams.publish(eventData);
-     */
     publish(data) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            data.eventId = (0, id_1.generateID)('HEX', 'FF'); // Added a unique Id to handle Message deduplication
+            if (data.eventId)
+                data.republishEvent = data.eventId;
+            data.eventId = (0, id_1.generateID)('HEX', 'FF');
+            if (!data.createdAt)
+                data.createdAt = Date.now();
             const transaction = this.redisPublisher.multi();
-            const consumerGroups = yield (0, groups_1.getAllConsumerGroups)(data.eventName, this.redisGroups);
+            const consumerGroups = yield (0, groups_1.getAllConsumerGroups)(data.eventName, this.redisPublisher);
             if (consumerGroups.length > 0) {
                 console.log(`Publishing event ${data.eventName} to consumer groups: ${consumerGroups.join(', ')}`);
                 for (const consumerGroup of consumerGroups) {
@@ -362,13 +352,13 @@ class Streams {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             console.log(`${this.eventsListened.length} events to be cleared`);
             for (const eventName of this.eventsListened) {
-                yield this.redisGroups.srem(`consumerGroups:${eventName}`, this.consumerGroupName);
+                yield this.redisGroups.srem(`${eventName}`, this.consumerGroupName);
             }
         });
     }
     registerConsumerGroup(eventName) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            yield this.redisGroups.sadd(`consumerGroups:${eventName}`, this.consumerGroupName);
+            yield this.redisGroups.sadd(`${eventName}`, this.consumerGroupName);
         });
     }
     cleanupAcknowledgedMessages(eventName, interval = 60 * 60 * 1000) {

package/src/lib/redis/types.d.ts

@@ -1,7 +1,13 @@
-export type EventData<T> = {
-    data: T;
-    eventName: string;
+export type EventData<TData, TName extends string> = {
+    data: TData;
+    eventName: TName;
     eventId?: string;
+    createdAt?: number;
+    republishEvent?: string;
+};
+export type PublishData<TData, TName extends string> = {
+    data: TData;
+    eventName: TName;
 };
 export type PendingMessages = [never, never, string, string, Array<[string, number]>];
 export type ClaimedMessages = Array<[never, string]>;

package/src/README.md

@@ -1,43 +0,0 @@
-# publisher
-
-publisher is a library for implementing an event-driven architecture using Redis PUB/SUB and Redis Streams. It provides a simple and scalable mechanism for publishing and consuming events in real-time, and supports features such as message deduplication, consumer group management, and scheduled event publishing.
-
-## Simple Example
-
-```typescript
-import { Publisher, EventData } from '@jetit/streams';
-
-// Create an instance of the publisher
-const streams = new Streams('Websockets');
-
-// Publish an event
-const eventData: EventData<{ message: string }> = {
-    eventName: 'my-event',
-    data: { message: 'Hello, world!' }
-};
-
-await streams.publish(eventData);
-
-// Subscribe to an event
-streams.listen('my-event').subscribe(event => {
-    console.log(`Received event: ${event.eventName}`, event.data);
-});
-```
-
-## Possible use cases
-
-1. Microservices communication: If your system is composed of multiple microservices, the publisher can be used to facilitate communication between them by publishing and listening to events.
-
-2. Event sourcing and CQRS: In an event-sourced system, the publisher can be used to store and process events that represent the state changes of the system, enabling Command Query Responsibility Segregation (CQRS) by separating the read and write models.
-
-3. Task queues: The publisher can be used to create task queues for distributing workloads among different worker instances, ensuring that tasks are processed in the order they were created.
-
-4. Data streaming and processing: The publisher can be used to ingest and process large volumes of data in real-time, such as log files, clickstream data, or other event-based data.
-
-5. Distributed system coordination: In a distributed system, the publisher can be used for coordination between different components, such as managing leader election or maintaining configuration information.
-
-6. Real-time analytics and monitoring: The publisher can be used to collect and process real-time analytics data, such as user behavior, application performance metrics, or system monitoring information.
-
-7. Event-driven workflows: You can use the publisher to create event-driven workflows, where each step in the workflow is triggered by the completion of a previous step. This can be useful for orchestrating complex, multi-step processes.
-
-8. Message broadcasting: The publisher can be used to broadcast messages to multiple consumers or subscribers, allowing for efficient and scalable communication in applications with many components or services.