@restorecommerce/chassis-srv 0.3.2 → 0.3.6

package/lib/command-interface/index.js

@@ -1,18 +1,28 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    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) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandInterface = void 0;
-const _ = require("lodash");
-const database = require("./../database");
-const async = require("async");
+const _ = __importStar(require("lodash"));
+const database = __importStar(require("./../database"));
+const async = __importStar(require("async"));
 // For some reason this is required
 const crypto = require('crypto');
 const ServingStatus = {
@@ -114,33 +124,31 @@ class CommandInterface {
      * @param call
      * @param context
      */
-    command(call, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(call.request) && _.isNil(call.name)) {
-                const result = {
-                    error: {
-                        code: 400,
-                        message: 'No command name provided',
-                    }
-                };
-                return this.encodeMsg(result);
-            }
-            const name = call.name || call.request.name;
-            if (_.isNil(this.commands[name])) {
-                const result = {
-                    error: {
-                        code: 400,
-                        message: `Command name ${name} does not exist`
-                    }
-                };
-                return this.encodeMsg(result);
-            }
-            const payload = call.payload ? this.decodeMsg(call.payload) :
-                (call.request.payload ? this.decodeMsg(call.request.payload) : null);
-            // calling operation bound to the command name
-            const result = yield this.commands[name].apply(this, [payload]);
+    async command(call, context) {
+        if (_.isNil(call.request) && _.isNil(call.name)) {
+            const result = {
+                error: {
+                    code: 400,
+                    message: 'No command name provided',
+                }
+            };
             return this.encodeMsg(result);
-        });
+        }
+        const name = call.name || call.request.name;
+        if (_.isNil(this.commands[name])) {
+            const result = {
+                error: {
+                    code: 400,
+                    message: `Command name ${name} does not exist`
+                }
+            };
+            return this.encodeMsg(result);
+        }
+        const payload = call.payload ? this.decodeMsg(call.payload) :
+            (call.request.payload ? this.decodeMsg(call.request.payload) : null);
+        // calling operation bound to the command name
+        const result = await this.commands[name].apply(this, [payload]);
+        return this.encodeMsg(result);
     }
     /**
      * Reconfigure service
@@ -162,200 +170,198 @@ class CommandInterface {
      * ArangoDB database collections, using the chassis-srv database provider.
      * @param topics list of Kafka topics to be restored
      */
-    restore(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isEmpty(payload) || _.isEmpty(payload.data)) {
-                // throw new errors.InvalidArgument('Invalid payload for restore command');
-                return {
-                    error: {
-                        code: 400,
-                        message: 'Invalid payload for restore command'
+    async restore(payload) {
+        if (_.isEmpty(payload) || _.isEmpty(payload.data)) {
+            // throw new errors.InvalidArgument('Invalid payload for restore command');
+            return {
+                error: {
+                    code: 400,
+                    message: 'Invalid payload for restore command'
+                }
+            };
+        }
+        const restoreData = payload.data || [];
+        // the Kafka config should contains a key-value pair, mapping
+        // a label with the topic's name
+        const kafkaEventsCfg = this.config.get('events:kafka');
+        const kafkaCfg = this.config.get('events:kafka:topics');
+        if (_.isNil(kafkaCfg) || kafkaCfg.length == 0) {
+            return {
+                error: {
+                    code: 500,
+                    message: 'Kafka topics config not available'
+                }
+            };
+        }
+        const topicLabels = _.keys(kafkaCfg).filter((elem, index) => {
+            return elem.includes('.resource');
+        }).map((elem) => {
+            return elem.replace('.resource', '');
+        });
+        const restoreSetup = {};
+        const restoreEventSetup = {};
+        restoreData.forEach((data) => {
+            const ignoreOffset = (data.ignore_offset || []).filter((offset) => {
+                const isNumber = Number(offset) != NaN;
+                if (!isNumber) {
+                    this.logger.warn(`Invalid value for "ignore_offset" parameter in restore: ${offset}`);
+                }
+                return isNumber;
+            });
+            restoreSetup[data.entity] = {
+                baseOffset: Number(data.base_offset) || 0,
+                ignoreOffset
+            };
+        });
+        const restoreCollections = _.keys(restoreSetup);
+        try {
+            const dbCfgs = this.config.get('database');
+            const dbCfgNames = _.keys(dbCfgs);
+            for (let i = 0; i < dbCfgNames.length; i += 1) {
+                const dbCfgName = dbCfgNames[i];
+                const dbCfg = dbCfgs[dbCfgName];
+                const collections = dbCfg.collections;
+                let graphName, edgeConfigDefs;
+                if (this.config.get('graph')) {
+                    graphName = this.config.get('graph:graphName');
+                    edgeConfigDefs = this.config.get('graph:edgeDefinitions');
+                }
+                const db = await database.get(dbCfg, this.logger, graphName, edgeConfigDefs);
+                if (_.isNil(collections)) {
+                    this.logger.warn('No collections found on DB config');
+                    return {};
+                }
+                let intersection = _.intersection(restoreCollections, collections);
+                if (intersection.length > 0) {
+                    intersection = _.intersection(intersection, topicLabels);
+                    for (let resource of intersection) {
+                        const topicName = kafkaCfg[`${resource}.resource`].topic;
+                        restoreEventSetup[topicName] = {
+                            topic: await this.kafkaEvents.topic(topicName),
+                            events: this.makeResourcesRestoreSetup(db, resource),
+                            baseOffset: restoreSetup[resource].baseOffset,
+                            ignoreOffset: restoreSetup[resource].ignoreOffset
+                        };
                     }
-                };
+                }
             }
-            const restoreData = payload.data || [];
-            // the Kafka config should contains a key-value pair, mapping
-            // a label with the topic's name
-            const kafkaEventsCfg = this.config.get('events:kafka');
-            const kafkaCfg = this.config.get('events:kafka:topics');
-            if (_.isNil(kafkaCfg) || kafkaCfg.length == 0) {
-                return {
-                    error: {
-                        code: 500,
-                        message: 'Kafka topics config not available'
-                    }
-                };
+            if (_.isEmpty(restoreEventSetup)) {
+                this.logger.warn('No data was setup for the restore process.');
             }
-            const topicLabels = _.keys(kafkaCfg).filter((elem, index) => {
-                return elem.includes('.resource');
-            }).map((elem) => {
-                return elem.replace('.resource', '');
-            });
-            const restoreSetup = {};
-            const restoreEventSetup = {};
-            restoreData.forEach((data) => {
-                const ignoreOffset = (data.ignore_offset || []).filter((offset) => {
-                    const isNumber = Number(offset) != NaN;
-                    if (!isNumber) {
-                        this.logger.warn(`Invalid value for "ignore_offset" parameter in restore: ${offset}`);
-                    }
-                    return isNumber;
-                });
-                restoreSetup[data.entity] = {
-                    baseOffset: Number(data.base_offset) || 0,
-                    ignoreOffset
-                };
-            });
-            const restoreCollections = _.keys(restoreSetup);
-            try {
-                const dbCfgs = this.config.get('database');
-                const dbCfgNames = _.keys(dbCfgs);
-                for (let i = 0; i < dbCfgNames.length; i += 1) {
-                    const dbCfgName = dbCfgNames[i];
-                    const dbCfg = dbCfgs[dbCfgName];
-                    const collections = dbCfg.collections;
-                    let graphName, edgeConfigDefs;
-                    if (this.config.get('graph')) {
-                        graphName = this.config.get('graph:graphName');
-                        edgeConfigDefs = this.config.get('graph:edgeDefinitions');
-                    }
-                    const db = yield database.get(dbCfg, this.logger, graphName, edgeConfigDefs);
-                    if (_.isNil(collections)) {
-                        this.logger.warn('No collections found on DB config');
-                        return {};
-                    }
-                    let intersection = _.intersection(restoreCollections, collections);
-                    if (intersection.length > 0) {
-                        intersection = _.intersection(intersection, topicLabels);
-                        for (let resource of intersection) {
-                            const topicName = kafkaCfg[`${resource}.resource`].topic;
-                            restoreEventSetup[topicName] = {
-                                topic: yield this.kafkaEvents.topic(topicName),
-                                events: this.makeResourcesRestoreSetup(db, resource),
-                                baseOffset: restoreSetup[resource].baseOffset,
-                                ignoreOffset: restoreSetup[resource].ignoreOffset
-                            };
-                        }
+            else {
+                const that = this;
+                // Start the restore process
+                this.logger.warn('restoring data');
+                for (let topicName in restoreEventSetup) {
+                    const topicSetup = restoreEventSetup[topicName];
+                    const restoreTopic = topicSetup.topic;
+                    const topicEvents = topicSetup.events;
+                    // saving listeners for potentially subscribed events on this topic,
+                    // so they don't get called during the restore process
+                    const previousEvents = _.cloneDeep(restoreTopic.subscribed);
+                    const listenersBackup = new Map();
+                    for (let event of previousEvents) {
+                        listenersBackup.set(event, restoreTopic.emitter.listeners(event));
+                        await restoreTopic.removeAllListeners(event);
                     }
-                }
-                if (_.isEmpty(restoreEventSetup)) {
-                    this.logger.warn('No data was setup for the restore process.');
-                }
-                else {
-                    const that = this;
-                    // Start the restore process
-                    this.logger.warn('restoring data');
-                    for (let topicName in restoreEventSetup) {
-                        const topicSetup = restoreEventSetup[topicName];
-                        const restoreTopic = topicSetup.topic;
-                        const topicEvents = topicSetup.events;
-                        // saving listeners for potentially subscribed events on this topic,
-                        // so they don't get called during the restore process
-                        const previousEvents = _.cloneDeep(restoreTopic.subscribed);
-                        const listenersBackup = new Map();
-                        for (let event of previousEvents) {
-                            listenersBackup.set(event, restoreTopic.emitter.listeners(event));
-                            yield restoreTopic.removeAllListeners(event);
-                        }
-                        // const eventNames = _.keys(restoreTopic.events);
-                        const baseOffset = topicSetup.baseOffset;
-                        const targetOffset = (yield restoreTopic.$offset(-1)) - 1;
-                        const ignoreOffsets = topicSetup.ignoreOffset;
-                        const eventNames = _.keys(topicEvents);
-                        this.logger.debug(`topic ${topicName} has current offset ${targetOffset}`);
-                        const restoreGroupId = kafkaEventsCfg.groupId + '-restore-' + crypto.randomBytes(32).toString('hex');
-                        const consumer = this.kafkaEvents.provider.client.consumer({
-                            groupId: restoreGroupId
+                    // const eventNames = _.keys(restoreTopic.events);
+                    const baseOffset = topicSetup.baseOffset;
+                    const targetOffset = (await restoreTopic.$offset(-1)) - 1;
+                    const ignoreOffsets = topicSetup.ignoreOffset;
+                    const eventNames = _.keys(topicEvents);
+                    this.logger.debug(`topic ${topicName} has current offset ${targetOffset}`);
+                    const restoreGroupId = kafkaEventsCfg.groupId + '-restore-' + crypto.randomBytes(32).toString('hex');
+                    const consumer = this.kafkaEvents.provider.client.consumer({
+                        groupId: restoreGroupId
+                    });
+                    const drainEvent = (message, done) => {
+                        const msg = message.value;
+                        const eventName = message.key.toString();
+                        const context = _.pick(message, ['offset', 'partition', 'topic']);
+                        const eventListener = topicEvents[message.key];
+                        // decode protobuf
+                        let decodedMsg = that.kafkaEvents.provider.decodeObject(kafkaEventsCfg, eventName, msg);
+                        decodedMsg = _.pick(decodedMsg, _.keys(decodedMsg)); // preventing protobuf.js special fields
+                        eventListener(decodedMsg, context, that.config.get(), eventName).then(() => {
+                            done();
+                        }).catch((err) => {
+                            that.logger.error(`Exception caught invoking restore listener for event ${eventName}:`, err);
+                            done(err);
                         });
-                        const drainEvent = (message, done) => {
-                            const msg = message.value;
-                            const eventName = message.key.toString();
-                            const context = _.pick(message, ['offset', 'partition', 'topic']);
-                            const eventListener = topicEvents[message.key];
-                            // decode protobuf
-                            let decodedMsg = that.kafkaEvents.provider.decodeObject(kafkaEventsCfg, eventName, msg);
-                            decodedMsg = _.pick(decodedMsg, _.keys(decodedMsg)); // preventing protobuf.js special fields
-                            eventListener(decodedMsg, context, that.config.get(), eventName).then(() => {
-                                done();
-                            }).catch((err) => {
-                                that.logger.error(`Exception caught invoking restore listener for event ${eventName}:`, err);
-                                done(err);
-                            });
-                            if (message.offset >= targetOffset) {
-                                for (let event of eventNames) {
-                                    restoreTopic.removeAllListeners(event).then(() => { }).catch((err) => {
-                                        that.logger.error('Error removing listeners after restore', err);
+                        if (message.offset >= targetOffset) {
+                            for (let event of eventNames) {
+                                restoreTopic.removeAllListeners(event).then(() => { }).catch((err) => {
+                                    that.logger.error('Error removing listeners after restore', err);
+                                });
+                            }
+                            for (let event of previousEvents) {
+                                const listeners = listenersBackup.get(event);
+                                for (let listener of listeners) {
+                                    restoreTopic.on(event, listener).then(() => { }).catch((err) => {
+                                        that.logger.error('Error subscribing to listeners after restore', err);
                                     });
                                 }
-                                for (let event of previousEvents) {
-                                    const listeners = listenersBackup.get(event);
-                                    for (let listener of listeners) {
-                                        restoreTopic.on(event, listener).then(() => { }).catch((err) => {
-                                            that.logger.error('Error subscribing to listeners after restore', err);
-                                        });
-                                    }
-                                }
-                                consumer.stop().then(() => consumer.disconnect()).then(() => {
-                                    this.kafkaEvents.provider.admin.deleteGroups([restoreGroupId]).then(() => {
-                                        that.logger.debug('restore kafka group deleted');
-                                        const msg = {
-                                            topic: topicName,
-                                            offset: message.offset
-                                        };
-                                        that.commandTopic.emit('restoreResponse', {
-                                            services: _.keys(that.service),
-                                            payload: that.encodeMsg(msg)
-                                        }).then(() => {
-                                            that.logger.info('Restore response emitted');
-                                        }).catch((err) => {
-                                            that.logger.error('Error emitting command response', err);
-                                        });
-                                        that.logger.info('restore process done');
-                                    }).catch(err => {
-                                        that.logger.error('Error deleting restore kafka group:', err);
+                            }
+                            consumer.stop().then(() => consumer.disconnect()).then(() => {
+                                this.kafkaEvents.provider.admin.deleteGroups([restoreGroupId]).then(() => {
+                                    that.logger.debug('restore kafka group deleted');
+                                    const msg = {
+                                        topic: topicName,
+                                        offset: message.offset
+                                    };
+                                    that.commandTopic.emit('restoreResponse', {
+                                        services: _.keys(that.service),
+                                        payload: that.encodeMsg(msg)
+                                    }).then(() => {
+                                        that.logger.info('Restore response emitted');
+                                    }).catch((err) => {
+                                        that.logger.error('Error emitting command response', err);
                                     });
+                                    that.logger.info('restore process done');
                                 }).catch(err => {
-                                    that.logger.error('Error stopping consumer:', err);
+                                    that.logger.error('Error deleting restore kafka group:', err);
                                 });
+                            }).catch(err => {
+                                that.logger.error('Error stopping consumer:', err);
+                            });
+                        }
+                    };
+                    const asyncQueue = that.startToReceiveRestoreMessages(restoreTopic, drainEvent);
+                    await consumer.connect().catch(err => {
+                        that.logger.error(`error connecting consumer:`, err);
+                        throw err;
+                    });
+                    await consumer.subscribe({
+                        topic: topicName,
+                    });
+                    await consumer.run({
+                        eachMessage: async (payload) => {
+                            if (payload.message.key.toString() in topicEvents && !_.includes(ignoreOffsets, parseInt(payload.message.offset))) {
+                                asyncQueue.push(payload.message);
+                                that.logger.debug(`received message ${payload.message.offset}/${targetOffset}`);
                             }
-                        };
-                        const asyncQueue = that.startToReceiveRestoreMessages(restoreTopic, drainEvent);
-                        yield consumer.connect().catch(err => {
-                            that.logger.error(`error connecting consumer:`, err);
-                            throw err;
-                        });
-                        yield consumer.subscribe({
-                            topic: topicName,
-                        });
-                        yield consumer.run({
-                            eachMessage: (payload) => __awaiter(this, void 0, void 0, function* () {
-                                if (payload.message.key.toString() in topicEvents && !_.includes(ignoreOffsets, parseInt(payload.message.offset))) {
-                                    asyncQueue.push(payload.message);
-                                    that.logger.debug(`received message ${payload.message.offset}/${targetOffset}`);
-                                }
-                            })
-                        });
-                        yield consumer.seek({
-                            topic: topicName,
-                            partition: 0,
-                            offset: baseOffset.toString(10)
-                        });
-                    }
-                    this.logger.debug('waiting until all messages are processed');
+                        }
+                    });
+                    await consumer.seek({
+                        topic: topicName,
+                        partition: 0,
+                        offset: baseOffset.toString(10)
+                    });
                 }
+                this.logger.debug('waiting until all messages are processed');
             }
-            catch (err) {
-                console.log('Err is...........', err);
-                this.logger.error('Error occurred while restoring the system', err.message);
-                yield this.commandTopic.emit('restoreResponse', {
-                    services: _.keys(this.service),
-                    payload: this.encodeMsg({
-                        error: err.message
-                    })
-                });
-            }
-            return {};
-        });
+        }
+        catch (err) {
+            console.log('Err is...........', err);
+            this.logger.error('Error occurred while restoring the system', err.message);
+            await this.commandTopic.emit('restoreResponse', {
+                services: _.keys(this.service),
+                payload: this.encodeMsg({
+                    error: err.message
+                })
+            });
+        }
+        return {};
     }
     startToReceiveRestoreMessages(restoreTopic, drainEvent) {
         const asyncQueue = async.queue((msg, done) => {
@@ -382,202 +388,192 @@ class CommandInterface {
      * Reset system data related to a service. Default implementation truncates
      * a set of ArangoDB instances, using the chassis-srv database provider.
      */
-    reset() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.info('reset process started');
-            if (this.health.status !== ServingStatus.NOT_SERVING) {
-                this.logger.warn('reset process starting while server is serving');
-            }
-            let errorMsg = null;
-            try {
-                const dbCfgs = this.config.get('database');
-                const dbCfgNames = _.keys(dbCfgs);
-                for (let i = 0; i < dbCfgNames.length; i += 1) {
-                    const dbCfgName = dbCfgNames[i];
-                    const dbCfg = dbCfgs[dbCfgName];
-                    const db = yield database.get(dbCfg, this.logger);
-                    switch (dbCfg.provider) {
-                        case 'arango':
-                            yield db.truncate();
-                            this.logger.info(`arangodb ${dbCfg.database} truncated`);
-                            break;
-                        default:
-                            this.logger.error(`unsupported database provider ${dbCfg.provider} in database config ${dbCfgName}`);
-                            break;
-                    }
+    async reset() {
+        this.logger.info('reset process started');
+        if (this.health.status !== ServingStatus.NOT_SERVING) {
+            this.logger.warn('reset process starting while server is serving');
+        }
+        let errorMsg = null;
+        try {
+            const dbCfgs = this.config.get('database');
+            const dbCfgNames = _.keys(dbCfgs);
+            for (let i = 0; i < dbCfgNames.length; i += 1) {
+                const dbCfgName = dbCfgNames[i];
+                const dbCfg = dbCfgs[dbCfgName];
+                const db = await database.get(dbCfg, this.logger);
+                switch (dbCfg.provider) {
+                    case 'arango':
+                        await db.truncate();
+                        this.logger.info(`arangodb ${dbCfg.database} truncated`);
+                        break;
+                    default:
+                        this.logger.error(`unsupported database provider ${dbCfg.provider} in database config ${dbCfgName}`);
+                        break;
                 }
             }
-            catch (err) {
-                this.logger.error('Unexpected error while resetting the system', err.message);
-                errorMsg = err.message;
-            }
-            const eventObject = {
-                services: _.keys(this.service),
-                payload: null
-            };
-            if (errorMsg) {
-                eventObject.payload = this.encodeMsg({
-                    error: errorMsg
-                });
-            }
-            else {
-                eventObject.payload = this.encodeMsg({
-                    status: 'Reset concluded successfully'
-                });
-            }
-            yield this.commandTopic.emit('resetResponse', eventObject);
-            this.logger.info('reset process ended');
-            if (errorMsg) {
-                return {
-                    error: errorMsg
-                };
-            }
-            return {
+        }
+        catch (err) {
+            this.logger.error('Unexpected error while resetting the system', err.message);
+            errorMsg = err.message;
+        }
+        const eventObject = {
+            services: _.keys(this.service),
+            payload: null
+        };
+        if (errorMsg) {
+            eventObject.payload = this.encodeMsg({
+                error: errorMsg
+            });
+        }
+        else {
+            eventObject.payload = this.encodeMsg({
                 status: 'Reset concluded successfully'
+            });
+        }
+        await this.commandTopic.emit('resetResponse', eventObject);
+        this.logger.info('reset process ended');
+        if (errorMsg) {
+            return {
+                error: errorMsg
             };
-        });
+        }
+        return {
+            status: 'Reset concluded successfully'
+        };
     }
     /**
      * Check the service status
      * @param call List of services to be checked
      * @param context
      */
-    check(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(payload)) {
-                return {
-                    error: {
-                        code: 400,
-                        message: 'Invalid payload for restore command'
-                    }
-                };
-            }
-            const serviceName = payload.service;
-            if (_.isNil(serviceName) || _.size(serviceName) === 0) {
-                yield this.commandTopic.emit('healthCheckResponse', {
-                    services: _.keys(this.service),
-                    payload: this.encodeMsg({
-                        status: this.health.status,
-                    })
-                });
-                return {
-                    status: this.health.status,
-                };
-            }
-            const service = this.service[serviceName];
-            if (_.isNil(service)) {
-                const errorMsg = 'Service ' + serviceName + ' does not exist';
-                this.logger.warn(errorMsg);
-                return {
-                    error: {
-                        code: 404,
-                        message: errorMsg
-                    }
-                };
-            }
-            let status = ServingStatus.UNKNOWN;
-            // If one transports serves the service, set it to SERVING
-            _.forEach(service.transport, (transportStatus) => {
-                if (transportStatus === ServingStatus.SERVING) {
-                    status = transportStatus;
+    async check(payload) {
+        if (_.isNil(payload)) {
+            return {
+                error: {
+                    code: 400,
+                    message: 'Invalid payload for restore command'
                 }
-            });
-            yield this.commandTopic.emit('healthCheckResponse', {
-                services: [serviceName],
+            };
+        }
+        const serviceName = payload.service;
+        if (_.isNil(serviceName) || _.size(serviceName) === 0) {
+            await this.commandTopic.emit('healthCheckResponse', {
+                services: _.keys(this.service),
                 payload: this.encodeMsg({
-                    status,
+                    status: this.health.status,
                 })
             });
             return {
-                status,
+                status: this.health.status,
             };
+        }
+        const service = this.service[serviceName];
+        if (_.isNil(service)) {
+            const errorMsg = 'Service ' + serviceName + ' does not exist';
+            this.logger.warn(errorMsg);
+            return {
+                error: {
+                    code: 404,
+                    message: errorMsg
+                }
+            };
+        }
+        let status = ServingStatus.UNKNOWN;
+        // If one transports serves the service, set it to SERVING
+        _.forEach(service.transport, (transportStatus) => {
+            if (transportStatus === ServingStatus.SERVING) {
+                status = transportStatus;
+            }
         });
+        await this.commandTopic.emit('healthCheckResponse', {
+            services: [serviceName],
+            payload: this.encodeMsg({
+                status,
+            })
+        });
+        return {
+            status,
+        };
     }
     /**
      * Retrieve current NPM package and Node version of service
      */
-    version() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = {
-                nodejs: process.version,
-                version: process.env.npm_package_version,
-            };
-            yield this.commandTopic.emit('versionResponse', {
-                services: _.keys(this.service),
-                payload: this.encodeMsg(response)
-            });
-            return response;
+    async version() {
+        const response = {
+            nodejs: process.version,
+            version: process.env.npm_package_version,
+        };
+        await this.commandTopic.emit('versionResponse', {
+            services: _.keys(this.service),
+            payload: this.encodeMsg(response)
         });
+        return response;
     }
     /**
      * Update config for acs-client to disable it
      * @param payload JSON object containing key value pairs for configuration
      */
-    configUpdate(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(payload)) {
-                return {
-                    error: {
-                        code: 400,
-                        message: 'Invalid payload for configUpdate command'
-                    }
-                };
-            }
-            let response;
-            try {
-                let configProperties = Object.keys(payload);
-                for (let key of configProperties) {
-                    this.config.set(key, payload[key]);
+    async configUpdate(payload) {
+        if (_.isNil(payload)) {
+            return {
+                error: {
+                    code: 400,
+                    message: 'Invalid payload for configUpdate command'
                 }
-                response = {
-                    status: 'Configuration updated successfully'
-                };
-                yield this.commandTopic.emit('configUpdateResponse', {
-                    services: _.keys(this.service),
-                    payload: this.encodeMsg(response)
-                });
-            }
-            catch (error) {
-                this.logger.error('Error executing configUpdate Command', { message: error.message });
-                response = error.message;
+            };
+        }
+        let response;
+        try {
+            let configProperties = Object.keys(payload);
+            for (let key of configProperties) {
+                this.config.set(key, payload[key]);
             }
-            return response;
-        });
+            response = {
+                status: 'Configuration updated successfully'
+            };
+            await this.commandTopic.emit('configUpdateResponse', {
+                services: _.keys(this.service),
+                payload: this.encodeMsg(response)
+            });
+        }
+        catch (error) {
+            this.logger.error('Error executing configUpdate Command', { message: error.message });
+            response = error.message;
+        }
+        return response;
     }
     /**
      * Sets provided authentication apiKey on configuration
      * @param payload JSON object containing key value pairs for authentication apiKey
      */
-    setApiKey(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(payload)) {
-                return {
-                    error: {
-                        code: 400,
-                        message: 'Invalid payload for setApiKey command'
-                    }
-                };
-            }
-            let response;
-            try {
-                let configProperties = Object.keys(payload);
-                for (let key of configProperties) {
-                    this.config.set(key, payload[key]);
+    async setApiKey(payload) {
+        if (_.isNil(payload)) {
+            return {
+                error: {
+                    code: 400,
+                    message: 'Invalid payload for setApiKey command'
                 }
-                response = {
-                    status: 'ApiKey set successfully'
-                };
-                yield this.commandTopic.emit('setApiKeyResponse', {
-                    services: _.keys(this.service),
-                    payload: this.encodeMsg(response)
-                });
-            }
-            catch (err) {
-                this.logger.error('Error executing setApiKey Command', { message: err.message });
-                response = err.message;
+            };
+        }
+        let response;
+        try {
+            let configProperties = Object.keys(payload);
+            for (let key of configProperties) {
+                this.config.set(key, payload[key]);
             }
-            return response;
-        });
+            response = {
+                status: 'ApiKey set successfully'
+            };
+            await this.commandTopic.emit('setApiKeyResponse', {
+                services: _.keys(this.service),
+                payload: this.encodeMsg(response)
+            });
+        }
+        catch (err) {
+            this.logger.error('Error executing setApiKey Command', { message: err.message });
+            response = err.message;
+        }
+        return response;
     }
     /**
     * Flush the cache based on DB index and prefix passed, if no dbIndex is passed
@@ -585,112 +581,110 @@ class CommandInterface {
     *
     * @param prefix An optional prefix to flush instead of entire cache
     */
-    flushCache(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let flushCachePayload;
-            if (payload && payload.data) {
-                flushCachePayload = payload.data;
-            }
-            let dbIndex, pattern, response;
-            if (flushCachePayload) {
-                dbIndex = flushCachePayload.db_index;
-                pattern = flushCachePayload.pattern;
-            }
-            if (dbIndex === undefined || !dbIndex) {
-                dbIndex = 0;
+    async flushCache(payload) {
+        let flushCachePayload;
+        if (payload && payload.data) {
+            flushCachePayload = payload.data;
+        }
+        let dbIndex, pattern, response;
+        if (flushCachePayload) {
+            dbIndex = flushCachePayload.db_index;
+            pattern = flushCachePayload.pattern;
+        }
+        if (dbIndex === undefined || !dbIndex) {
+            dbIndex = 0;
+        }
+        // select the particular dbIndex
+        await this.redisClient.select(dbIndex);
+        try {
+            if (pattern != undefined) {
+                let flushPattern = '*' + pattern + '*';
+                this.logger.debug('Flushing cache wiht pattern', { dbIndex, flushPattern });
+                let stream, pipeline;
+                try {
+                    stream = this.redisClient.scanStream({ match: flushPattern, count: 100 });
+                    pipeline = this.redisClient.pipeline();
+                }
+                catch (err) {
+                    this.logger.error('Error creating stream / pipeline in Redis', { message: err.message });
+                    response = err.message;
+                }
+                let localKeys = [];
+                if (stream && pipeline) {
+                    await new Promise((resolve, reject) => {
+                        stream.on('data', (resultKeys) => {
+                            this.logger.info('Data Received:', localKeys.length);
+                            for (let i = 0; i < resultKeys.length; i++) {
+                                localKeys.push(resultKeys[i]);
+                                pipeline.del(resultKeys[i]);
+                            }
+                            if (localKeys.length > 100) {
+                                pipeline.exec(() => { this.logger.info('one batch delete complete'); });
+                                localKeys = [];
+                                pipeline = this.redisClient.pipeline();
+                            }
+                        });
+                        stream.on('end', () => {
+                            pipeline.exec(() => { this.logger.info('final batch delete complete'); });
+                            response = {
+                                status: 'Successfully flushed cache pattern'
+                            };
+                            resolve(response);
+                        });
+                        stream.on('error', (err) => {
+                            this.logger.error('error', err);
+                            response = err.message;
+                            resolve(err);
+                        });
+                    });
+                }
             }
-            // select the particular dbIndex
-            yield this.redisClient.select(dbIndex);
-            try {
-                if (pattern != undefined) {
-                    let flushPattern = '*' + pattern + '*';
-                    this.logger.debug('Flushing cache wiht pattern', { dbIndex, flushPattern });
-                    let stream, pipeline;
-                    try {
-                        stream = this.redisClient.scanStream({ match: flushPattern, count: 100 });
-                        pipeline = this.redisClient.pipeline();
-                    }
-                    catch (err) {
-                        this.logger.error('Error creating stream / pipeline in Redis', { message: err.message });
-                        response = err.message;
+            else {
+                this.logger.debug('Flushing cache', { dbIndex });
+                await new Promise((resolve, reject) => {
+                    if (dbIndex || dbIndex === 0) {
+                        // Flush all keys in the given dbIndex (flushDB)
+                        this.redisClient.flushdb(async (err, reply) => {
+                            if (err) {
+                                this.logger.error('Failed flushing cache with DB index', { err, dbIndex });
+                                return reject();
+                            }
+                            if (reply) {
+                                this.logger.debug('Successfully flushed cache with DB index', { dbIndex });
+                                response = {
+                                    status: `Successfully flushed cache with DB index ${dbIndex}`
+                                };
+                                return resolve(response);
+                            }
+                        });
                     }
-                    let localKeys = [];
-                    if (stream && pipeline) {
-                        yield new Promise((resolve, reject) => {
-                            stream.on('data', (resultKeys) => {
-                                this.logger.info('Data Received:', localKeys.length);
-                                for (let i = 0; i < resultKeys.length; i++) {
-                                    localKeys.push(resultKeys[i]);
-                                    pipeline.del(resultKeys[i]);
-                                }
-                                if (localKeys.length > 100) {
-                                    pipeline.exec(() => { this.logger.info('one batch delete complete'); });
-                                    localKeys = [];
-                                    pipeline = this.redisClient.pipeline();
-                                }
-                            });
-                            stream.on('end', () => {
-                                pipeline.exec(() => { this.logger.info('final batch delete complete'); });
+                    else {
+                        // Flush Complete Redis Cache (flushAll)
+                        this.redisClient.flushall(async (err, reply) => {
+                            if (err) {
+                                this.logger.error('Failed flushing complete cache', { err });
+                                return reject();
+                            }
+                            if (reply) {
+                                this.logger.debug('Successfully flushed complete cache');
                                 response = {
-                                    status: 'Successfully flushed cache pattern'
+                                    status: 'Successfully flushed complete cache'
                                 };
-                                resolve(response);
-                            });
-                            stream.on('error', (err) => {
-                                this.logger.error('error', err);
-                                response = err.message;
-                                resolve(err);
-                            });
+                                return resolve(response);
+                            }
                         });
                     }
-                }
-                else {
-                    this.logger.debug('Flushing cache', { dbIndex });
-                    yield new Promise((resolve, reject) => {
-                        if (dbIndex || dbIndex === 0) {
-                            // Flush all keys in the given dbIndex (flushDB)
-                            this.redisClient.flushdb((err, reply) => __awaiter(this, void 0, void 0, function* () {
-                                if (err) {
-                                    this.logger.error('Failed flushing cache with DB index', { err, dbIndex });
-                                    return reject();
-                                }
-                                if (reply) {
-                                    this.logger.debug('Successfully flushed cache with DB index', { dbIndex });
-                                    response = {
-                                        status: `Successfully flushed cache with DB index ${dbIndex}`
-                                    };
-                                    return resolve(response);
-                                }
-                            }));
-                        }
-                        else {
-                            // Flush Complete Redis Cache (flushAll)
-                            this.redisClient.flushall((err, reply) => __awaiter(this, void 0, void 0, function* () {
-                                if (err) {
-                                    this.logger.error('Failed flushing complete cache', { err });
-                                    return reject();
-                                }
-                                if (reply) {
-                                    this.logger.debug('Successfully flushed complete cache');
-                                    response = {
-                                        status: 'Successfully flushed complete cache'
-                                    };
-                                    return resolve(response);
-                                }
-                            }));
-                        }
-                    });
-                }
-            }
-            catch (err) {
-                response = err.message;
+                });
             }
-            yield this.commandTopic.emit('flushCacheResponse', {
-                services: _.keys(this.service),
-                payload: this.encodeMsg(response)
-            });
-            return response;
+        }
+        catch (err) {
+            response = err.message;
+        }
+        await this.commandTopic.emit('flushCacheResponse', {
+            services: _.keys(this.service),
+            payload: this.encodeMsg(response)
         });
+        return response;
     }
     // Helper functions
     /**
@@ -701,25 +695,19 @@ class CommandInterface {
     makeResourcesRestoreSetup(db, resource) {
         const that = this;
         return {
-            [`${resource}Created`]: function restoreCreated(message, ctx, config, eventName) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    that.decodeBufferField(message, resource);
-                    yield db.insert(`${resource}s`, message);
-                    return {};
-                });
+            [`${resource}Created`]: async function restoreCreated(message, ctx, config, eventName) {
+                that.decodeBufferField(message, resource);
+                await db.insert(`${resource}s`, message);
+                return {};
             },
-            [`${resource}Modified`]: function restoreModified(message, ctx, config, eventName) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    that.decodeBufferField(message, resource);
-                    yield db.update(`${resource}s`, { id: message.id }, _.omitBy(message, _.isNil));
-                    return {};
-                });
+            [`${resource}Modified`]: async function restoreModified(message, ctx, config, eventName) {
+                that.decodeBufferField(message, resource);
+                await db.update(`${resource}s`, { id: message.id }, _.omitBy(message, _.isNil));
+                return {};
             },
-            [`${resource}Deleted`]: function restoreDeleted(message, ctx, config, eventName) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    yield db.delete(`${resource}s`, { id: message.id });
-                    return {};
-                });
+            [`${resource}Deleted`]: async function restoreDeleted(message, ctx, config, eventName) {
+                await db.delete(`${resource}s`, { id: message.id });
+                return {};
             }
         };
     }