@codefresh-io/eventbus 2.4.0 → 3.0.0-alpha.1

package/lib/Store.js

@@ -1,19 +1,29 @@
 "use strict";
 
-const EventEmitter = require('events');
-const Promise      = require('bluebird');
-const debug        = require('debug')('eventbus:store');
-const pg           = require('pg');
-const _            = require('lodash');
-const Cursor       = require('pg-cursor');
-const CFError      = require('cf-errors');
-const tables       = require('./tables');
-
-const INIT_RETRY_INTERVAL = 5; // in seconds
-const SCHEMA              = 'eventstore.events';
+const { promisify } = require('node:util');
+const EventEmitter  = require('node:events');
+const CFError       = require('cf-errors');
+const pg            = require('pg');
+const Cursor        = require('pg-cursor');
+const { logger }    = require('./logger');
+const tables        = require('./tables');
+
+const INIT_RETRY_INTERVAL_SEC = 5;
+const SCHEMA = 'eventstore.events';
 
 class Store extends EventEmitter {
+    _logger = logger.child(this.constructor.name);
 
+    /**
+     * @param {string} microServiceName
+     * @param {Object} options
+     * @param {string} [options.host]
+     * @param {string} [options.database]
+     * @param {string} [options.user]
+     * @param {string} [options.password]
+     * @param {number} [options.port]
+     * @param {boolean} [options.ssl]
+     */
     constructor(microServiceName, options) {
         super();
         this.microServiceName = microServiceName;
@@ -31,95 +41,92 @@ class Store extends EventEmitter {
             ? process.env.POSTGRES_SSL_ENABLE === 'true'
             : options.ssl;
         this.disablePostgresForEventbus = process.env.DISABLE_POSTGRES_FOR_EVENTBUS === 'true';
-        this.readyPromise     = new Promise((resolve, reject) => {
-            this.readyDeferred = {
-                resolve: () => {
-                    resolve();
-                },
-                reject: () => {
-                    reject();
-                }
-            };
-        });
+        /** @type {PromiseWithResolvers<void>} */
+        this.readyDeferred = Promise.withResolvers();
+        /** @type {Promise<void>} */
+        this.readyPromise = this.readyDeferred.promise;
     }
 
     async quit() {
-        if (this.disablePostgresForEventbus) {
-            return;
-        }
-        debug(`Pool client state before closing. total: ${this.pool.totalCount}. idle: ${this.pool.idleCount}. active: ${this.pool.activeCount}`);
+        this._logger.info(`Closing store for microservice "${this.microServiceName}"`);
+        if (this.disablePostgresForEventbus || !this.pool) return;
+
+        this._logger.debug(`Pool client state before closing: total: ${this.pool.totalCount}, idle: ${this.pool.idleCount}, waiting: ${this.pool.waitingCount}`);
         await this.pool.end();
-        debug(`Pool client state after closing. total: ${this.pool.totalCount}. idle: ${this.pool.idleCount}. active: ${this.pool.activeCount}`);
-        debug('store ');
+        this._logger.debug(`Pool client state after closing: total: ${this.pool.totalCount}, idle: ${this.pool.idleCount}, waiting: ${this.pool.waitingCount}`);
+        this._logger.info(`Store closed for microservice "${this.microServiceName}"`);
     }
 
-    init() {
+    async init() {
         if (this.disablePostgresForEventbus) {
-            debug(`Store is disabled. Skipping initialization of it`);
+            this._logger.info(`Store is disabled. Skipping initialization`);
             return;
         }
-        const config = {
-            user: this.user,
-            database: this.database,
-            password: this.password,
-            host: this.host,
-            port: this.port,
-            max: 10,
-            idleTimeoutMillis: 30000, // how long a client is allowed to remain idle before being closed
-            ssl: this.ssl,
-        };
-        this.pool    = new pg.Pool(config);
 
-        this.pool.on('error', (err) => {
-            this.emit('error', new CFError({
-                cause: err,
-                message: 'postgres pool error'
-            }));
-        });
+        try {
+            this._logger.info(`Initializing store for microservice "${this.microServiceName}"`);
+            this.pool = new pg.Pool({
+                user: this.user,
+                database: this.database,
+                password: this.password,
+                host: this.host,
+                port: this.port,
+                max: 10,
+                idleTimeoutMillis: 30000, // how long a client is allowed to remain idle before being closed
+                ssl: this.ssl,
+            });
 
-        this._assertSystemTables()
-            .then(() => {
-                debug(`ready`);
-                this.emit('ready');
-            })
-            .catch((err) => {
+            this.pool.on('error', (err) => {
                 this.emit('error', new CFError({
                     cause: err,
-                    message: `Initialization failed`
+                    message: 'postgres pool error'
                 }));
-                debug(`initialization failed trying again in ${INIT_RETRY_INTERVAL} seconds`);
-                setTimeout(() => {
-                    this.init();
-                }, INIT_RETRY_INTERVAL * 1000);
             });
+
+            await this._assertSystemTables();
+            this._logger.info(`Store initialized for microservice "${this.microServiceName}"`);
+            this.emit('ready');
+        } catch (exception) {
+            this.emit('error', new CFError({
+                cause: exception,
+                message: `Initialization failed`
+            }));
+            this._logger.error(`Store initialization failed for microservice "${this.microServiceName}"`, exception);
+            this._logger.info(`Retrying store initialization in ${INIT_RETRY_INTERVAL_SEC} seconds...`);
+            setTimeout(() => {
+                this.init();
+            }, INIT_RETRY_INTERVAL_SEC * 1000);
+        }
     }
 
     async _assertSystemTables() {
-        if (process.env.EVENTBUS_IGNORE_CREATE_SCHEMA){
-            return Promise.resolve();
-        }
-        await this.pool.query(tables);
-        debug('system tables asserted');
+        if (process.env.EVENTBUS_IGNORE_CREATE_SCHEMA) return;
+
+        this._logger.info('Asserting system tables');
+        await this.pool?.query(tables);
+        this._logger.info('System tables asserted');
     }
 
     /**
      * extends the pg cursor with an easy api for the client
-     * @param cursor
-     * @param queryCondition
+     * @param {Cursor} cursor
+     * @param {pg.PoolClient} client
+     * @param {string} queryCondition
+     * @return {void}
      * @private
      */
     _extendPgCursor(cursor, client, queryCondition) {
-        cursor.read = Promise.promisify(cursor.read.bind(cursor));
+        cursor.read = promisify(cursor.read.bind(cursor));
 
         cursor.count = async () => {
             const countResults = await this.pool.query(`SELECT COUNT(*) FROM ${SCHEMA} ${queryCondition}`);
-            const totalRows    = Number(countResults.rows[0].count);
+            const totalRows = Number(countResults.rows[0].count);
             return totalRows;
         };
 
         cursor.next = async () => {
             const rowResult = await cursor.read(1);
-            const row       = rowResult[0];
+            const row = rowResult[0];
             return row;
         };
 
@@ -137,28 +144,27 @@ class Store extends EventEmitter {
     }
 
     async save(eventName, event) {
-        if (this.disablePostgresForEventbus) {
-            return;
-        }
-        let data =  [
+        if (this.disablePostgresForEventbus) return;
+
+        const data =  [
             { field: 'event', value: eventName },
-            { field: 'props', value: _.get(event, 'props', {}) },
-            { field: 'aggregate_id', value: _.get(event, 'aggregateId', '').toString() },
-            { field: 'timestamp', value: _.get(event, 'timestamp', new Date()) },
-            { field: 'publisher', value: _.get(event, 'publisher', this.microServiceName) }
+            { field: 'props', value: event?.props ?? {} },
+            { field: 'aggregate_id', value: event?.aggregateId?.toString?.() ?? '' },
+            { field: 'timestamp', value: event?.timestamp ?? new Date() },
+            { field: 'publisher', value: event?.publisher ?? this.microServiceName },
         ];
 
         if (event.accountId) {
-            data.push({ field: 'account_id', value: _.get(event, 'accountId', '').toString() });
+            data.push({ field: 'account_id', value: event.accountId.toString?.() });
         }
 
         if (event.userId) {
-            data.push({ field: 'user_id', value: _.get(event, 'userId', '').toString() });
+            data.push({ field: 'user_id', value: event.userId.toString?.() });
         }
 
         let fieldString  = '';
         let valuesString = '';
-        let dataArr      = [];
+        const dataArr      = [];
         data.forEach((d, index) => {
             if (!index) {
                 fieldString += `${d.field}`;
@@ -176,21 +182,17 @@ class Store extends EventEmitter {
 
     async getAllAggregateEvents(aggregateId, fromIndex) {
         if (this.disablePostgresForEventbus) {
-            debug('getAllAggregateEvents: return _emptyPgCursor');
+            this._logger.debug('Store is disabled for Eventbus. Returning empty cursor');
             return this._emptyPgCursor();
         }
+
         try {
             const queryCondition = `WHERE id >= ${fromIndex} AND aggregate_id = '${aggregateId}'`;
-
             const client = await this.pool.connect();
-
             const cursor = await client.query(new Cursor(`SELECT * FROM ${SCHEMA} ${queryCondition} ORDER BY timestamp`));
-
             this._extendPgCursor(cursor, client, queryCondition);
-
             return cursor;
-        }
-        catch (err) {
+        } catch (err) {
             throw new CFError({
                 cause: err,
                 message: `Failed to perform getAllAggregateEvents with aggregateId: ${aggregateId}`
@@ -200,20 +202,16 @@ class Store extends EventEmitter {
 
     async getAllEventsByName(name, fromIndex) {
         if (this.disablePostgresForEventbus) {
-            debug('getAllEventsByName: return _emptyPgCursor');
+            this._logger.debug('Store is disabled for Eventbus. Returning empty cursor');
             return this._emptyPgCursor();
         }
+
         try {
             const queryCondition = `WHERE id >= ${fromIndex} AND event LIKE '${name}%'`;
-
             const client = await this.pool.connect();
-
             const cursor = await client.query(new Cursor(`SELECT * FROM ${SCHEMA} ${queryCondition} ORDER BY timestamp`));
-
             this._extendPgCursor(cursor, client, queryCondition);
-
             await cursor.count();
-
             return cursor;
         }
         catch (err) {
@@ -225,7 +223,4 @@ class Store extends EventEmitter {
     }
 }
 
-
-
-
 module.exports = Store;

package/lib/index.js

@@ -1,12 +1,10 @@
 'use strict';
 
-const EventEmitter = require('events');
-const Promise      = require('bluebird');
-const debug        = require('debug')('eventbus:main');
-const uuid         = require('uuid');
-const CFError      = require('cf-errors');
-const Bus          = require('./Bus');
-const Store        = require('./Store');
+const EventEmitter  = require('node:events');
+const CFError       = require('cf-errors');
+const Bus           = require('./Bus');
+const Store         = require('./Store');
+const { logger }    = require('./logger');
 
 //TODO
 // 1. queue published messages in case of failure in the connection
@@ -15,60 +13,89 @@ const Store        = require('./Store');
 // 4. add ability to get all possible event types in the system
 
 class EventBus extends EventEmitter {
+    _logger = logger.child(this.constructor.name);
 
     constructor() {
         super();
         this.busReady     = false;
         this.storeReady   = false;
-        this.readyPromise = new Promise((resolve, reject) => {
-            this.readyDeferred = {
-                resolve: () => {
-                    resolve();
-                },
-                reject: () => {
-                    reject();
-                }
-            };
-        });
+        /** @type {PromiseWithResolvers<void>} */
+        this.readyDeferred = Promise.withResolvers();
+        this.readyPromise  = this.readyDeferred.promise;
         this.on('error', () => {});
     }
 
-    quit() {
-        return Promise.resolve()
-            .then(async () => {
-                try {
-                    await Promise.all([this.bus.quit(), this.store.quit()]);
-                    this.emit('quit');
-                } catch (err) {
-                    throw new CFError({
-                        cause: err,
-                        message: 'Failed during quit execution'
-                    });
+    /**
+     * Unsubscribes all consumers and forbids new consumers from being subscribed.
+     * This should be used when you want to gracefully terminate the connection and ensure that no new messages are consumed while terminating.
+     * @returns {Promise<void>}
+     */
+    async cancelAllConsumers() {
+        await this.bus?.cancelAllConsumers();
+    }
+
+    /**
+     * Waits for all consumers in progress to finish.
+     * This should be used before terminating the connection
+     * to ensure that all messages are processed before the connection is closed.
+     * @returns {Promise<void>}
+     */
+    async waitForConsumersToFinish() {
+        await this.bus?.waitForConsumersToFinish();
+    }
+
+    /**
+     * Terminates the bus connection gracefully by cancelling all consumers, waiting for all consumers in progress to finish, and then closing the connection.
+     * @param {object} [options]
+     * @param {boolean} [options.force] If `true`, closes connection immediately.
+     */
+    async quit(options) {
+        try {
+            const results = await Promise.allSettled([
+                this.bus?.quit(options),
+                this.store?.quit(),
+            ]);
+            const failures = results.reduce((acc, result) => {
+                if (result.status === 'rejected') {
+                    acc.push(result.reason);
                 }
+                return acc;
+            }, /** @type {any[]} */ ([]));
+            if (failures.length > 0) {
+                const error = new AggregateError(failures, 'One or more errors occurred during EventBus termination');
+                this._logger.error(error);
+                throw error;
+            }
+            this.emit('quit');
+        } catch (err) {
+            throw new CFError({
+                cause: err,
+                message: 'Failed during quit execution'
             });
+        }
     }
 
     init(options = {}) {
-        this.microServiceName = options.microServiceName || options.serviceName || `eventBus_client_${uuid()}`;
+        this.microServiceName = options.microServiceName || options.serviceName || `eventBus_client_${globalThis.crypto.randomUUID()}`;
 
         this.bus   = new Bus(this.microServiceName, options.bus);
         this.store = new Store(this.microServiceName, options.store);
 
         // wait for both the bus and the store to send their ready event
         this.bus.on('ready', () => {
-            debug(`bus is ready. registered as: ${this.microServiceName}`);
+            this._logger.info(`Eventbus bus is ready. Registered as: ${this.microServiceName}`);
             this.busReady = true;
             this._emitReady();
         });
 
         this.store.on('ready', () => {
-            debug(`store is ready. registered as: ${this.microServiceName}`);
+            this._logger.info(`Eventbus store is ready. Registered as: ${this.microServiceName}`);
             this.storeReady = true;
             this._emitReady();
         });
 
         this.bus.on('error', (err) => {
-            debug(`bus error: ${err.toString()}`);
+            this._logger.error(`Eventbus bus error`, err);
             this.emit('error', new CFError({
                 cause: err,
                 message: 'eventbus bus error'
@@ -76,7 +103,7 @@ class EventBus extends EventEmitter {
         });
 
         this.store.on('error', (err) => {
-            debug(`store error: ${err.toString()}`);
+            this._logger.error(`Eventbus store error`, err);
             this.emit('error', new CFError({
                 cause: err,
                 message: 'eventbus store error'
@@ -90,27 +117,20 @@ class EventBus extends EventEmitter {
     _emitReady() {
         if (this.busReady) {
             this.readyDeferred.resolve();
-            debug('ready');
+            this._logger.info('Eventbus is ready');
             this.emit('ready');
         }
     }
 
-    publish(eventName, msg) {
-        return Promise.resolve()
-            .then(async () => {
-                await this.readyPromise;
-                await this.bus.publish(eventName, msg);
-            }).then(() => {
-                this.store.save(eventName, msg);
-            })
+    async publish(eventName, msg) {
+        await this.readyPromise;
+        await this.bus.publish(eventName, msg);
+        this.store.save(eventName, msg);
     }
 
-    subscribe(eventName, handler, options) {
-        return Promise.resolve()
-            .then(async () => {
-                await this.readyPromise;
-                return await this.bus.subscribe(eventName, handler, options);
-            });
+    async subscribe(eventName, handler, options) {
+        await this.readyPromise;
+        return this.bus.subscribe(eventName, handler, options);
     }
 
     /**
@@ -118,12 +138,9 @@ class EventBus extends EventEmitter {
      * @param aggregateId
      * @returns pg extended Cursor
      */
-    getAllAggregateEvents(aggregateId, fromIndex) {
-        return Promise.resolve()
-            .then(async () => {
-                await this.readyPromise;
-                return await this.store.getAllAggregateEvents(aggregateId, fromIndex);
-            });
+    async getAllAggregateEvents(aggregateId, fromIndex) {
+        await this.readyPromise;
+        return await this.store.getAllAggregateEvents(aggregateId, fromIndex);
     }
 
     /**
@@ -131,14 +148,10 @@ class EventBus extends EventEmitter {
      * @param name
      * @returns pg extended Cursor
      */
-    getAllEventsByName(name, fromIndex) {
-        return Promise.resolve()
-            .then(async () => {
-                await this.readyPromise;
-                return await this.store.getAllEventsByName(name, fromIndex);
-            });
+    async getAllEventsByName(name, fromIndex) {
+        await this.readyPromise;
+        return await this.store.getAllEventsByName(name, fromIndex);
     }
-
 }
 
 module.exports = new EventBus();

package/lib/logger.js

@@ -0,0 +1,5 @@
+const { Logger } = require('@codefresh-io/cf-telemetry/logs');
+
+const logger = new Logger('@codefresh-io/eventbus');
+
+module.exports = { logger };

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "@codefresh-io/eventbus",
-  "version": "2.4.0",
+  "version": "3.0.0-alpha.1",
   "description": "",
   "main": "index.js",
+  "files": [
+    "lib/**/*",
+    "index.js"
+  ],
   "scripts": {
-    "test": "gulp unit_test"
+    "test": "echo \"Not implemented\" && exit 0",
+    "lint": "echo \"Not implemented\" && exit 0",
+    "build": "echo \"Not required\" && exit 0"
   },
   "repository": {
     "type": "git",
@@ -16,37 +22,20 @@
     "url": "https://github.com/codefresh-io/cf-eventbus/issues"
   },
   "homepage": "https://github.com/codefresh-io/cf-eventbus#readme",
+  "engines": {
+    "node": ">=22 <=24"
+  },
   "dependencies": {
-    "amqplib": "^0.10.7",
-    "bluebird": "^3.5.0",
-    "cf-errors": "^0.1.16",
-    "debug": "2.6.9",
-    "lodash": "^4.17.21",
-    "pg": "^8.11.1",
-    "pg-cursor": "^1.2.0",
-    "uuid": "^3.0.1"
+    "amqplib": "^0.10.9",
+    "cf-errors": "^0.1.17",
+    "pg": "^8.19.0",
+    "pg-cursor": "^1.2.0"
   },
   "devDependencies": {
-    "chai": "^3.0.0",
-    "git-rev": "^0.2.1",
-    "gulp": "^3.9.1",
-    "gulp-coveralls": "^0.1.4",
-    "gulp-env": "^0.2.0",
-    "gulp-git": "^1.2.1",
-    "gulp-ignore": "^1.2.1",
-    "gulp-istanbul": "^0.10.4",
-    "gulp-jshint": "^1.11.0",
-    "gulp-logger": "0.0.2",
-    "gulp-mocha": "^2.1.1",
-    "gulp-nodemon": "^2.0.4",
-    "gulp-rimraf": "^0.1.1",
-    "gulp-run": "^1.6.7",
-    "gulp-util": "^3.0.6",
-    "isparta": "^4.0.0",
-    "proxyquire": "^1.7.10",
-    "run-sequence": "^1.1.0",
-    "sinon": "^1.15.4",
-    "sinon-chai": "^2.8.0"
+    "@codefresh-io/cf-telemetry": "^3.11.1"
+  },
+  "peerDependencies": {
+    "@codefresh-io/cf-telemetry": "^3.11.1"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/.dockerignore

@@ -1,2 +0,0 @@
-node_modules
-logs/*.log

package/.eslintrc

@@ -1,71 +0,0 @@
-// Codefresh Code Style - eslint ruleset
-// Based on AirBnB.
-//
-// More details: https://codefresh-io.atlassian.net/wiki/display/COD/Code+Style+Guide
-{
-  "env": {
-    "node": true,
-    "mocha": true
-  },
-
-  "plugins": [
-    "chai-friendly"
-  ],
-
-  "extends": "airbnb",
-  "parserOptions": {
-    "ecmaVersion": 6,
-    "sourceType": "script",
-    "ecmaFeatures": {
-      "jsx": true
-    }
-  },
-
-  "rules": {
-    "max-len": [1, 130],
-    "indent": [
-      "error",
-      4,
-      {
-        "SwitchCase": 1,
-        "VariableDeclarator": 1
-      }
-    ],
-    "func-names": [
-      "error",
-      "never"
-    ],
-    "quotes": [
-      "error",
-      "single",
-      {
-        "allowTemplateLiterals": true
-      }
-    ],
-    "no-underscore-dangle": "off",
-    "no-param-reassign": "off",
-    "no-else-return": "off",
-    "arrow-body-style": "off",
-    "strict": [
-      "error",
-      "global"
-    ],
-    "no-multi-spaces": "off",
-    "padded-blocks": "off",
-    "import/no-extraneous-dependencies": [
-      2,
-      {
-        "devDependencies": true
-      }
-    ],
-    "guard-for-in": "error",
-    "no-console": "off",
-    "comma-dangle": ["error", "only-multiline"],
-    "quote-props": ["error", "consistent"],
-    "class-methods-use-this": "off",
-    "no-use-before-define": ["error", { "functions": false, "classes": true }],
-    "no-restricted-syntax": ["error", "WithStatement", "ForInStatement", "LabeledStatement"],
-    "no-unused-expressions": 0,
-    "chai-friendly/no-unused-expressions": 2
-  }
-}

package/Dockerfile

@@ -1,15 +0,0 @@
-FROM node:6.9.2
-
-RUN npm install --global yarn
-
-COPY ./package.json /app/
-
-RUN cd /app && yarn install
-
-COPY . /app/
-
-WORKDIR /app
-
-CMD [ "yarn", "start" ]
-
-EXPOSE 3000