@shushed/helpers 0.0.197 → 0.0.198-v2-20251104135028

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

@@ -0,0 +1,446 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 isSubscriptionOptionsPull(opts) {
+    return 'endpointUrl' in opts && opts.endpointUrl === null;
+}
+function isSubscriptionOptionsPush(opts) {
+    return 'endpointUrl' in opts && !!opts.endpointUrl && (opts.endpointUrl.startsWith('https://') || opts.endpointUrl.startsWith('http://'));
+}
+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, payload) {
+        if (!pubSubPublishTopics[options.topicName]) {
+            pubSubPublishTopics[options.topicName] = this.pubSub.topic(options.topicName, {
+                batching: {
+                    maxMessages: 100,
+                    maxMilliseconds: 50
+                },
+            });
+        }
+        const topic = pubSubPublishTopics[options.topicName];
+        let normPayloads = [];
+        if (!Array.isArray(payload)) {
+            normPayloads = [payload];
+        }
+        else {
+            normPayloads = payload;
+        }
+        const batches = normPayloads.length > 5 ? (0, lodash_chunk_1.default)(normPayloads, 10) : [normPayloads];
+        const attributes = {
+            ...(0, lodash_omit_1.default)(options.extraAttributes || {}, ['source_system', 'target_system', 'buildship_id', 'bigquery']),
+            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: options.attributesGenerator ? Object.assign({}, attributes, options.attributesGenerator(x)) : attributes
+            })));
+            for (const result of results) {
+                if (result.status === 'fulfilled') {
+                    messageIds.push(result.value);
+                }
+                else {
+                    messageIds.push(null);
+                }
+            }
+            if (i !== batches.length - 1) {
+                await new Promise(resolve => setTimeout(resolve, 30));
+            }
+        }
+        return messageIds;
+    }
+    async createOrUpdate(opts) {
+        const [topics] = await this.pubSub.getTopics();
+        const topicName = opts.topicName;
+        const mainSubscriptionName = opts.subscriptionName || opts.topicName;
+        const mainDlqTopicName = `${mainSubscriptionName}.dlq`;
+        const tableDlqTopicName = `${mainSubscriptionName}.bq.dlq`;
+        const mainDlqSubscriptionName = `${mainSubscriptionName}.dlq`;
+        const tableSubscriptionName = `${mainSubscriptionName}.bq`;
+        const tableDlqSubscriptionName = `${topicName}.bq.dlq`;
+        let mainTopic = topics.find(x => this.getNameFromFullyQualifiedName(x.name) === opts.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 || opts.pull || opts.push) {
+            mainTopic = 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,
+                    endpointUrl: null,
+                    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 || opts.push;
+        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,
+                    endpointUrl: null,
+                });
+            }
+            mainSubscription = await this.ensureSubscribtionExists(mainSubscriptionName, {
+                topic,
+                dlqTopic: mainDlqTopic || null,
+                exactlyOnceDelivery: opts.push ? false : true,
+                subscriptionFilter: opts.subscriptionFilter,
+                endpointUrl: opts.push ? this.runtimeUrl + `/executeWorkflow/${this.workflowId}/${this.triggerId}?topic_name=${opts.topicName}` : null,
+                retryMinDelay: pullPushSubscription.retryMinDelay,
+                retryMaxDelay: pullPushSubscription.retryMaxDelay,
+                retryLimit: pullPushSubscription.retryLimit,
+                ackDeadline: Math.max(pullPushSubscription.ackDeadline, opts.push ? 10 : 60)
+            });
+        }
+        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,
+            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()
+            }
+        };
+        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 (isSubscriptionOptionsPush(opts)) {
+            if (opts.endpointUrl !== subscriptionMetaData?.pushConfig?.pushEndpoint
+                || this.serviceAccountEmail !== subscriptionMetaData?.pushConfig.oidcToken?.serviceAccountEmail
+                || process.env.GCLOUD_PROJECT + "/" + this.triggerId !== subscriptionMetaData.pushConfig.oidcToken.audience) {
+                if (subscriptionMetaData?.pushConfig?.pushEndpoint && subscription) {
+                    try {
+                        await subscription.modifyPushConfig({
+                            pushEndpoint: opts.endpointUrl,
+                            oidcToken: {
+                                serviceAccountEmail: this.serviceAccountEmail,
+                                audience: process.env.GCLOUD_PROJECT + "/" + this.triggerId,
+                            },
+                        });
+                    }
+                    catch (err) {
+                        this.logging.error('Invariant: While updating push subscription', err.message, err.stack);
+                        throw new Error('Invariant: While updating push subscription - ' + err.message);
+                    }
+                }
+                else if (opts.endpointUrl) {
+                    nextMetadata = nextMetadata || {};
+                    nextMetadata.pushConfig = {
+                        pushEndpoint: opts.endpointUrl,
+                        oidcToken: {
+                            serviceAccountEmail: this.serviceAccountEmail,
+                            audience: process.env.GCLOUD_PROJECT + "/" + this.triggerId,
+                        },
+                    };
+                }
+            }
+        }
+        else {
+            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' && isSubscriptionOptionsPull(opts)) {
+                nextMetadata = nextMetadata || {};
+                nextMetadata.enableExactlyOnceDelivery = opts.exactlyOnceDelivery;
+            }
+            else {
+                nextMetadata = nextMetadata || {};
+                nextMetadata.enableExactlyOnceDelivery = null;
+            }
+        }
+        if ((opts.subscriptionFilter && subscriptionMetaData?.filter) && opts.subscriptionFilter !== subscriptionMetaData?.filter) {
+            nextMetadata = nextMetadata || {};
+            nextMetadata.filter = opts.subscriptionFilter;
+        }
+        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-triggerid': this.triggerId.toLowerCase(),
+            'bs-workflowid': this.workflowId.toLowerCase(),
+            'bs-envname': this.systemEnvName.toLowerCase(),
+            'bs-is-deadletter': subscriptionName.indexOf('-dlq') > -1 ? 'true' : 'false',
+            'bs-is-push-enabled': isSubscriptionOptionsPush(opts) && opts.endpointUrl ? 'true' : 'false',
+            'bs-bigquery-tableid': !(isSubscriptionOptionsPush(opts) || isSubscriptionOptionsPull(opts)) && opts.tableId ? opts.tableId.replace(/\./g, '-').toLowerCase() : '',
+            'bs-is-bigquery': !(isSubscriptionOptionsPush(opts) || isSubscriptionOptionsPull(opts)) && opts.tableId ? 'true' : 'false',
+        };
+        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 (!isSubscriptionOptionsPull(opts) && !isSubscriptionOptionsPush(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;
+        }
+        if (subscription && nextMetadata) {
+            try {
+                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 - ' + 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) {
+            await opts.topic.createSubscription(subscriptionName, createPayload);
+            [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

@@ -0,0 +1,140 @@
+"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

@@ -0,0 +1,44 @@
+"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;
+}