@shushed/helpers 0.0.202 → 0.0.203-bug-erp-770-20251208112219

package/dist/cjs/src-public/pubsub.js

@@ -1,423 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSubscriptionBigQuery = isSubscriptionBigQuery;
-const co_body_1 = __importDefault(require("co-body"));
-const lodash_chunk_1 = __importDefault(require("lodash.chunk"));
-const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
-const lodash_omit_1 = __importDefault(require("lodash.omit"));
-const runtime_1 = __importDefault(require("./runtime"));
-const utils_1 = require("./utils");
-function isPubSubMessage(req) {
-    return req && typeof req.ack === 'function' && typeof req.data !== 'undefined' && typeof req.ackId !== 'undefined';
-}
-const pubSubPublishTopics = global.HUSH_PUBSUB_PUBLISH_TOPICS || {};
-global.HUSH_PUBSUB_PUBLISH_TOPICS = pubSubPublishTopics;
-function isSubscriptionBigQuery(opts) {
-    return 'tableId' in opts && opts.tableId !== null;
-}
-class PubSubHelper extends runtime_1.default {
-    serviceAccountEmail;
-    pubSub;
-    constructor(opts, pubsubOrSettings, pubSub) {
-        super(opts);
-        if (!pubSub) {
-            this.pubSub = pubsubOrSettings;
-            this.serviceAccountEmail = opts.serviceAccountEmail;
-        }
-        else {
-            this.pubSub = pubSub;
-            this.serviceAccountEmail = pubsubOrSettings.serviceAccountEmail;
-        }
-    }
-    static async decodeMessageFromRequest(req) {
-        let rawMessage;
-        let rawBody;
-        if (!isPubSubMessage(req)) {
-            rawMessage = await co_body_1.default.json(req);
-            rawBody = Buffer.from(rawMessage.message?.data, "base64").toString('utf-8');
-        }
-        else {
-            rawMessage = {
-                message: req
-            };
-            rawBody = req.data.toString('utf-8');
-        }
-        let messageBody;
-        try {
-            messageBody = JSON.parse(rawBody);
-        }
-        catch (err) {
-            throw new Error('Could not parse the message body. Original body: ' + rawBody + ' . Error: ' + err.message);
-        }
-        const message = {
-            messageId: rawMessage.message?.messageId || undefined,
-            sourceSystem: rawMessage.message?.attributes?.source_system || 'unknown',
-            targetSystem: rawMessage.message?.attributes?.target_system || '*',
-            processStartedAt: (0, utils_1.parseDateOrDefault)(rawMessage.message?.attributes?.process_started_at),
-            recordModifiedAt: (0, utils_1.parseDateOrDefault)((0, utils_1.getEventTime)(messageBody, rawMessage.attributes?.record_modified_at)),
-            originalPublishTime: (0, utils_1.parseDateOrDefault)(rawMessage.message?.attributes?.original_publish_time, (0, utils_1.parseDateOrDefault)(rawMessage.message?.publish_time)),
-            buildshipId: rawMessage.message.attributes?.buildship_id || 'unknown',
-            publishTime: (0, utils_1.parseDateOrDefault)(rawMessage.message?.publish_time),
-            body: messageBody,
-            bodyTxt: rawBody,
-            extraAttributes: (0, lodash_omit_1.default)(rawMessage.message?.attributes || {}, ['source_system', 'target_system', 'process_started_at', 'record_modified_at', 'original_publish_time', 'buildship_id', 'publish_time', 'bigquery']),
-            subscriptionName: rawMessage.subscription?.split('/').pop(),
-        };
-        return message;
-    }
-    async publish(options, payloads) {
-        if (!pubSubPublishTopics[options.topicName]) {
-            pubSubPublishTopics[options.topicName] = this.pubSub.topic(options.topicName, {
-                batching: {
-                    maxMessages: 10,
-                    maxMilliseconds: 15
-                },
-            });
-        }
-        const topic = pubSubPublishTopics[options.topicName];
-        const batches = payloads.length > 5 ? (0, lodash_chunk_1.default)(payloads, 10) : [payloads];
-        const attributes = {
-            ...options.extraAttributes,
-            source_system: options.sourceSystem,
-            target_system: options.targetSystem,
-            buildship_id: this.systemEnvName + '-' + this.workflowId + '-' + this.triggerId,
-        };
-        const messageIds = [];
-        for (let i = 0; i < batches.length; i++) {
-            const batch = batches[i];
-            const results = await Promise.allSettled(batch.map((x) => topic.publishMessage({
-                data: Buffer.from(JSON.stringify(x)),
-                attributes: Object.fromEntries(Object.entries(options.attributesGenerator ? Object.assign({}, attributes, options.attributesGenerator(x)) : attributes).filter(([_, v]) => v !== undefined && v !== null).map(([k, v]) => [k, `${v}`]))
-            })));
-            for (const result of results) {
-                if (result.status === 'fulfilled') {
-                    messageIds.push(result.value);
-                }
-                else {
-                    messageIds.push(result.reason instanceof Error ? result.reason : new Error(result.reason));
-                }
-            }
-            if (i !== batches.length - 1) {
-                await new Promise(resolve => setTimeout(resolve, 30));
-            }
-        }
-        return messageIds;
-    }
-    async createOrUpdate(opts) {
-        const [topics] = await this.pubSub.getTopics();
-        let topicName = opts.topicName;
-        if (topicName.indexOf('rn.') !== 0 && /^\d/.test(topicName)) {
-            topicName = `rn.${topicName}`;
-        }
-        const mainSubscriptionName = opts.subscriptionName || topicName;
-        const tableSubscriptionName = `${mainSubscriptionName}.bq`;
-        const mainDlqTopicName = `${mainSubscriptionName}.dlq`;
-        const mainDlqSubscriptionName = `${mainSubscriptionName}.dlq`;
-        const tableDlqTopicName = `${mainSubscriptionName}.bq.dlq`;
-        const tableDlqSubscriptionName = `${mainSubscriptionName}.bq.dlq`;
-        const mainTopic = topics.find(x => this.getNameFromFullyQualifiedName(x.name) === topicName);
-        let mainDlqTopic = topics.find(x => this.getNameFromFullyQualifiedName(x.name) === mainDlqTopicName);
-        let tableDlqTopic = topics.find(x => this.getNameFromFullyQualifiedName(x.name) === tableDlqTopicName);
-        let mainTopicSubscriptions = null;
-        let mainDlqTopicSubscriptions = null;
-        let tableDlqTopicSubscriptions = null;
-        if (mainTopic) {
-            [mainTopicSubscriptions] = await mainTopic.getSubscriptions();
-        }
-        if (mainDlqTopic) {
-            [mainDlqTopicSubscriptions] = await mainDlqTopic.getSubscriptions();
-        }
-        if (tableDlqTopic) {
-            [tableDlqTopicSubscriptions] = await tableDlqTopic.getSubscriptions();
-        }
-        let mainSubscription = mainTopicSubscriptions?.find(x => this.getNameFromFullyQualifiedName(x.name) === mainSubscriptionName) || null;
-        let mainDlqSubscription = mainDlqTopicSubscriptions?.find(x => this.getNameFromFullyQualifiedName(x.name) === mainDlqSubscriptionName) || null;
-        let tableSubscription = mainTopicSubscriptions?.find(x => this.getNameFromFullyQualifiedName(x.name) === tableSubscriptionName) || null;
-        let tableDlqSubscription = tableDlqTopicSubscriptions?.find(x => this.getNameFromFullyQualifiedName(x.name) === tableDlqSubscriptionName) || null;
-        const topic = await this.ensureTopicExists(opts.topicName);
-        if (!opts.table) {
-            if (tableSubscription) {
-                await tableSubscription.delete();
-                tableSubscription = null;
-            }
-            if (tableDlqSubscription) {
-                await tableDlqSubscription.delete();
-                tableDlqSubscription = null;
-            }
-        }
-        else {
-            if (opts.createDeadLetterQueues) {
-                tableDlqTopic = await this.ensureTopicExists(tableDlqTopicName);
-                tableDlqSubscription = await this.ensureSubscribtionExists(tableDlqSubscriptionName, {
-                    topic: tableDlqTopic,
-                    dlqTopic: null,
-                });
-            }
-            tableSubscription = await this.ensureSubscribtionExists(tableSubscriptionName, {
-                topic: topic,
-                tableId: opts.table.tableId,
-                ackDeadline: opts.table.ackDeadline,
-                retryLimit: opts.table.retryLimit,
-                retryMinDelay: opts.table.retryMinDelay,
-                retryMaxDelay: opts.table.retryMaxDelay,
-                dlqTopic: tableDlqTopic || null
-            });
-        }
-        const pullPushSubscription = opts.pull;
-        if (!pullPushSubscription) {
-            if (mainSubscription) {
-                await mainSubscription.delete();
-                mainSubscription = null;
-            }
-            if (mainDlqSubscription) {
-                await mainDlqSubscription.delete();
-                mainDlqSubscription = null;
-            }
-        }
-        else {
-            if (opts.createDeadLetterQueues) {
-                mainDlqTopic = await this.ensureTopicExists(mainDlqTopicName);
-                mainDlqSubscription = await this.ensureSubscribtionExists(mainDlqSubscriptionName, {
-                    topic: mainDlqTopic,
-                    dlqTopic: null,
-                });
-            }
-            mainSubscription = await this.ensureSubscribtionExists(mainSubscriptionName, {
-                topic,
-                dlqTopic: mainDlqTopic || null,
-                exactlyOnceDelivery: true,
-                subscriptionFilter: opts.subscriptionFilter,
-                retryMinDelay: pullPushSubscription.retryMinDelay,
-                retryMaxDelay: pullPushSubscription.retryMaxDelay,
-                retryLimit: pullPushSubscription.retryLimit,
-                ackDeadline: pullPushSubscription.ackDeadline
-            });
-        }
-        if (!opts.createDeadLetterQueues) {
-            if (mainDlqSubscription) {
-                await mainDlqSubscription.delete();
-                mainDlqSubscription = null;
-            }
-            if (tableDlqSubscription) {
-                await tableDlqSubscription.delete();
-                tableDlqSubscription = null;
-            }
-            if (tableDlqTopic) {
-                await tableDlqTopic.delete();
-            }
-            if (mainDlqTopic)
-                await mainDlqTopic.delete();
-        }
-        return {
-            mainTopic: topic,
-            mainDlqTopic,
-            tableDlqTopic,
-            mainSubscription,
-            mainDlqSubscription,
-            tableDlqSubscription,
-            tableSubscription,
-        };
-    }
-    async findTopic(topicName) {
-        const [topics] = await this.pubSub.getTopics();
-        return topics.find(topic => this.getNameFromFullyQualifiedName(topic.name) === topicName);
-    }
-    async ensureTopicExists(topicName) {
-        let topic = await this.findTopic(topicName);
-        let topicMetadata;
-        try {
-            [topicMetadata] = await topic?.getMetadata() || [null];
-        }
-        catch (err) {
-            throw new Error('Invariant: While getting topic metadata - ' + err.message);
-        }
-        const metadata = {
-            labels: {
-                'bs-envname': this.systemEnvName.toLowerCase(),
-                'env': this.envName.toLowerCase(),
-                'bs-is-deadletter': topicName.indexOf('.dlq') > -1 ? '1' : '0',
-                'respectful-nudge': '1'
-            }
-        };
-        if (topic && !process.env.PUBSUB_EMULATOR_HOST) {
-            const simMetadata = Object.assign({}, topicMetadata?.labels || {}, metadata.labels);
-            if (!(0, lodash_isequal_1.default)(topicMetadata?.labels, simMetadata)) {
-                simMetadata['last-modified-at'] = new Date().getTime().toString();
-                try {
-                    await topic.setMetadata({
-                        labels: simMetadata
-                    });
-                }
-                catch (err) {
-                    this.logging.error('ensureTopicExists received error while setting metadata', err.message, err.stack);
-                    throw err;
-                }
-            }
-        }
-        else if (!topic) {
-            const payload = {
-                name: topicName,
-            };
-            if (!process.env.PUBSUB_EMULATOR_HOST) {
-                payload.labels = metadata.labels;
-            }
-            await this.pubSub.createTopic(payload);
-            topic = await this.findTopic(topicName);
-        }
-        if (!topic) {
-            throw new Error(`Invariant: While creating topic - topic is not found`);
-        }
-        return topic;
-    }
-    getNameFromFullyQualifiedName(fullyQName) {
-        const name = fullyQName.split('/');
-        return name[name.length - 1];
-    }
-    async updateSubscription(subscriptionName, subscription, subscriptionMetaData, inputOpts) {
-        const defaultOptions = {
-            retryLimit: 5,
-            retryMinDelay: 10,
-            retryMaxDelay: 360,
-            ackDeadline: 90,
-            exactlyOnceDelivery: false
-        };
-        const opts = Object.assign({}, defaultOptions, inputOpts);
-        let nextMetadata = null;
-        if (!isSubscriptionBigQuery(opts)) {
-            if (subscriptionMetaData?.pushConfig?.pushEndpoint) {
-                nextMetadata = nextMetadata || {};
-                nextMetadata.pushConfig = null;
-            }
-        }
-        if (opts.dlqTopic) {
-            if (opts.dlqTopic.name !== subscriptionMetaData?.deadLetterPolicy?.deadLetterTopic
-                || opts.retryLimit !== subscriptionMetaData?.deadLetterPolicy?.maxDeliveryAttempts) {
-                nextMetadata = nextMetadata || {};
-                nextMetadata.deadLetterPolicy = {
-                    deadLetterTopic: opts.dlqTopic.name,
-                    maxDeliveryAttempts: opts.retryLimit
-                };
-            }
-        }
-        else if (subscriptionMetaData?.deadLetterPolicy?.deadLetterTopic) {
-            nextMetadata = nextMetadata || {};
-            nextMetadata.deadLetterPolicy = null;
-        }
-        if (opts.exactlyOnceDelivery !== subscriptionMetaData?.enableExactlyOnceDelivery) {
-            if (typeof opts.exactlyOnceDelivery === 'boolean' && !isSubscriptionBigQuery(opts)) {
-                nextMetadata = nextMetadata || {};
-                nextMetadata.enableExactlyOnceDelivery = opts.exactlyOnceDelivery;
-            }
-            else {
-                nextMetadata = nextMetadata || {};
-                nextMetadata.enableExactlyOnceDelivery = null;
-            }
-        }
-        if (!isSubscriptionBigQuery(opts)) {
-            if ((opts.subscriptionFilter && subscriptionMetaData?.filter) && opts.subscriptionFilter !== subscriptionMetaData?.filter) {
-                nextMetadata = nextMetadata || {};
-                nextMetadata.filter = opts.subscriptionFilter || null;
-            }
-        }
-        if (opts.retryMinDelay != subscriptionMetaData?.retryPolicy?.minimumBackoff?.seconds
-            || opts.retryMaxDelay != subscriptionMetaData?.retryPolicy?.maximumBackoff?.seconds) {
-            nextMetadata = nextMetadata || {};
-            nextMetadata.retryPolicy = {
-                minimumBackoff: { seconds: opts.retryMinDelay },
-                maximumBackoff: { seconds: opts.retryMaxDelay }
-            };
-        }
-        const proposedLabels = {
-            'env': this.envName.toLowerCase(),
-            'bs-workflowid': this.workflowId.toLowerCase(),
-            'bs-envname': this.systemEnvName.toLowerCase(),
-            'bs-is-deadletter': subscriptionName.indexOf('.dlq') > -1 ? '1' : '0',
-            'bs-bigquery-tableid': isSubscriptionBigQuery(opts) && opts.tableId ? opts.tableId.replace(/\./g, '-').toLowerCase() : '',
-            'bs-is-bigquery': isSubscriptionBigQuery(opts) && opts.tableId ? '1' : '0',
-            'respectful-nudge': '1'
-        };
-        const simLabels = Object.assign({}, subscriptionMetaData?.labels || {}, proposedLabels);
-        if (!(0, lodash_isequal_1.default)(simLabels, subscriptionMetaData?.labels)) {
-            nextMetadata = nextMetadata || {};
-            nextMetadata.labels = simLabels;
-        }
-        if (opts.ackDeadline !== subscriptionMetaData?.ackDeadlineSeconds) {
-            nextMetadata = nextMetadata || {};
-            nextMetadata.ackDeadlineSeconds = opts.ackDeadline;
-        }
-        if (isSubscriptionBigQuery(opts)) {
-            if (opts.tableId !== subscriptionMetaData?.bigqueryConfig?.table || this.serviceAccountEmail !== subscriptionMetaData?.bigqueryConfig?.serviceAccountEmail) {
-                if (opts.tableId) {
-                    nextMetadata = nextMetadata || {};
-                    nextMetadata.bigqueryConfig = {
-                        table: opts.tableId,
-                        writeMetadata: true,
-                        dropUnknownFields: true,
-                        serviceAccountEmail: this.serviceAccountEmail,
-                        useTableSchema: false,
-                    };
-                }
-                else {
-                    nextMetadata = nextMetadata || {};
-                    nextMetadata.bigqueryConfig = null;
-                }
-            }
-        }
-        else if (subscriptionMetaData?.bigqueryConfig?.table) {
-            nextMetadata = nextMetadata || {};
-            nextMetadata.bigqueryConfig = null;
-        }
-        this.logging.log('ensureSubscribtionExists updating subscription ' + subscriptionName, nextMetadata);
-        if (subscription && nextMetadata) {
-            try {
-                if (isSubscriptionBigQuery(opts) && opts.tableId) {
-                    nextMetadata.bigqueryConfig = {
-                        table: opts.tableId,
-                        writeMetadata: true,
-                        dropUnknownFields: true,
-                        serviceAccountEmail: this.serviceAccountEmail,
-                        useTableSchema: false,
-                    };
-                }
-                await subscription.setMetadata(nextMetadata);
-            }
-            catch (err) {
-                this.logging.error('updateSubscription received error while setting metadata', err.message, err.stack);
-                throw new Error('Invariant: While updating subscription - ' + subscriptionName + ' - ' + err.message);
-            }
-        }
-        return nextMetadata;
-    }
-    async ensureSubscribtionExists(subscriptionName, opts) {
-        let [subscriptions] = await opts.topic.getSubscriptions();
-        let subscription = subscriptions.find((subscription) => this.getNameFromFullyQualifiedName(subscription.name) === subscriptionName) || null;
-        let subscriptionMetaData;
-        try {
-            [subscriptionMetaData] = (await subscription?.getMetadata()) || [null];
-        }
-        catch (err) {
-            throw new Error('Invariant: While getting subscription metadata - ' + err.message);
-        }
-        const createPayload = await this.updateSubscription(subscriptionName, subscription, subscriptionMetaData, opts);
-        if (createPayload && !subscription) {
-            this.logging.log('ensureSubscribtionExists creating subscription ' + subscriptionName, createPayload);
-            try {
-                await opts.topic.createSubscription(subscriptionName, createPayload);
-            }
-            catch (err) {
-                this.logging.error('ensureSubscribtionExists received error while creating subscription ' + subscriptionName, err.message, err.stack);
-                throw new Error('Invariant: While creating subscription - ' + err.message);
-            }
-            [subscriptions] = await opts.topic.getSubscriptions();
-            subscription = subscriptions.find(subscription => this.getNameFromFullyQualifiedName(subscription.name) === subscriptionName) || null;
-        }
-        if (!subscription) {
-            throw new Error(`Invariant: While creating subscription - subscription is not found`);
-        }
-        return subscription;
-    }
-}
-exports.default = PubSubHelper;

package/dist/cjs/src-public/rateLimit.js

@@ -1,140 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisConnectionError = void 0;
-class RedisConnectionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'RedisConnectionError';
-    }
-}
-exports.RedisConnectionError = RedisConnectionError;
-const runtime_1 = __importDefault(require("./runtime"));
-function normalizeId(id) {
-    return encodeURIComponent(id);
-}
-class RateLimit extends runtime_1.default {
-    redisInstance;
-    constructor(opts, redisInstance) {
-        super(opts);
-        this.redisInstance = redisInstance;
-    }
-    async acquireLock(id, maxConcurrentExecutions, expirationInSeconds = 60 * 5) {
-        const key = `ratelimit:${normalizeId(id)}`;
-        const now = Date.now();
-        const lockInfo = {
-            id,
-            workflowId: this.workflowId,
-            triggerId: this.triggerId,
-            url: this.runtimeUrl,
-            envName: this.envName,
-            creation_time: now,
-            expiration_time: now + expirationInSeconds * 1000,
-        };
-        try {
-            const timeout = 300;
-            const redis = this.redisInstance;
-            if (!redis.isOpen) {
-                try {
-                    await Promise.race([
-                        redis.connect(),
-                        new Promise((_, reject) => setTimeout(() => reject(new RedisConnectionError('Redis connect timeout')), timeout)),
-                    ]);
-                }
-                catch (err) {
-                    if (err instanceof RedisConnectionError)
-                        throw err;
-                    throw new RedisConnectionError(err.message);
-                }
-            }
-            await Promise.race([
-                redis.zRemRangeByScore(key, '-inf', now),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Redis timeout')), timeout)),
-            ]);
-            const count = await Promise.race([
-                redis.zCard(key),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Redis timeout')), timeout)),
-            ]);
-            if (count >= maxConcurrentExecutions) {
-                return false;
-            }
-            await Promise.race([
-                redis.zAdd(key, { score: lockInfo.expiration_time, value: JSON.stringify(lockInfo) }),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Redis timeout')), timeout)),
-            ]);
-            await Promise.race([
-                redis.expire(key, expirationInSeconds),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Redis timeout')), timeout)),
-            ]);
-            return true;
-        }
-        catch (err) {
-            if (err instanceof RedisConnectionError)
-                throw err;
-            return false;
-        }
-    }
-    async releaseLock(id) {
-        const key = `ratelimit:${normalizeId(id)}`;
-        const redis = this.redisInstance;
-        const timeout = 300;
-        if (!redis.isOpen) {
-            try {
-                await Promise.race([
-                    redis.connect(),
-                    new Promise((_, reject) => setTimeout(() => reject(new RedisConnectionError('Redis connect timeout')), timeout)),
-                ]);
-            }
-            catch (err) {
-                if (err instanceof RedisConnectionError)
-                    throw err;
-                throw new RedisConnectionError(err.message);
-            }
-        }
-        const locks = await redis.zRange(key, 0, -1);
-        const filtered = locks.filter((lockStr) => {
-            try {
-                const lock = JSON.parse(lockStr);
-                return lock.workflowId === this.workflowId && lock.triggerId === this.triggerId && lock.envName === this.envName && lock.url === this.runtimeUrl;
-            }
-            catch {
-                return false;
-            }
-        });
-        for (const lockStr of filtered) {
-            await redis.zRem(key, lockStr);
-        }
-    }
-    async viewLocks(id) {
-        const key = `ratelimit:${normalizeId(id)}`;
-        const redis = this.redisInstance;
-        const timeout = 300;
-        if (!redis.isOpen) {
-            try {
-                await Promise.race([
-                    redis.connect(),
-                    new Promise((_, reject) => setTimeout(() => reject(new RedisConnectionError('Redis connect timeout')), timeout)),
-                ]);
-            }
-            catch (err) {
-                if (err instanceof RedisConnectionError)
-                    throw err;
-                throw new RedisConnectionError(err.message);
-            }
-        }
-        const now = Date.now();
-        await redis.zRemRangeByScore(key, '-inf', now);
-        const locks = await redis.zRange(key, 0, -1);
-        return locks.reduce((acc, lockStr) => {
-            try {
-                acc.push(JSON.parse(lockStr));
-            }
-            catch {
-            }
-            return acc;
-        }, []);
-    }
-}
-exports.default = RateLimit;

package/dist/cjs/src-public/redisClient.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getRedisClient;
-exports.getConnectedRedisClient = getConnectedRedisClient;
-const redis_1 = require("redis");
-global.REDIS_CLIENTS = global.REDIS_CLIENTS || {};
-function getRedisClient(sysEnv) {
-    const jsonEnv = JSON.parse(process.env[`${sysEnv}ProjectEnv`] || '{}');
-    const redisEndpoint = jsonEnv['redis_host'];
-    let REDIS_CLIENT = global.REDIS_CLIENTS;
-    if (!REDIS_CLIENTS[redisEndpoint]) {
-        if (!redisEndpoint && process.env.K_REVISION) {
-            throw new Error('Invariant: Redis endpoint is not set in the Environment Variables. Please set the redis_host with a value of IP:PORT i.e. 10.67.130.27:6379');
-        }
-        else if (!redisEndpoint) {
-            return null;
-        }
-        REDIS_CLIENT = (0, redis_1.createClient)({
-            url: `redis://${redisEndpoint}`
-        });
-        global.REDIS_CLIENTS[redisEndpoint] = REDIS_CLIENT;
-    }
-    return global.REDIS_CLIENTS[redisEndpoint];
-}
-function getConnectedRedisClient(url) {
-    const redisClient = getRedisClient(url);
-    if (!redisClient) {
-        return Promise.resolve(null);
-    }
-    let race = Promise.resolve(redisClient);
-    if (!redisClient.isOpen) {
-        race = Promise.race([
-            redisClient.connect().then(() => redisClient).catch((err) => {
-                console.log('Hush - Redis connect error', err.message);
-                return null;
-            }),
-            new Promise((resolve) => setTimeout(() => {
-                console.log('Hush - Redis connect timeout');
-                resolve(null);
-            }, 100)),
-        ]);
-    }
-    return race;
-}