@ercworldio/blockchain-shared 1.0.0-dev.4

package/build/services/Redis.js

@@ -0,0 +1,317 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_1 = require("redis");
+const Parsing_1 = require("../utils/Parsing");
+const ElasticSearch_1 = __importDefault(require("./ElasticSearch"));
+const Logger_1 = require("../utils/Logger");
+class Redis {
+    constructor(config) {
+        this.initializingPromise = null;
+        this.create_redis_client = () => {
+            if (this.config.serverConfig.environment === 'local') {
+                this.client = (0, redis_1.createClient)();
+            }
+            else {
+                const parsed_string = (0, Parsing_1.parseRedisUrl)(this.config.config.redisConnectionstring);
+                let url = `rediss://${parsed_string.host}:${parsed_string.port}`;
+                this.client = (0, redis_1.createClient)({
+                    pingInterval: 10000,
+                    url,
+                    password: parsed_string.password,
+                    socket: {
+                        host: parsed_string.host,
+                        port: parsed_string.port,
+                        tls: true,
+                        reconnectStrategy: (retries) => {
+                            if (retries > 20)
+                                return new Error('Max retries reached');
+                            return Math.min(retries * 200, 5000);
+                        }
+                        // reconnectStrategy: (retries) => {
+                        //     if (retries < 10) {
+                        //         return 200;
+                        //     }
+                        //     // this.reinitialize();
+                        //     return false;
+                        // }
+                    }
+                });
+            }
+            return this.client;
+        };
+        this.config = config;
+        this.initialized = false;
+        this.prefix = `${config.serverConfig.projectName}-${config.serverConfig.environment}`;
+        this.client = this.create_redis_client();
+        this.logger = (0, Logger_1.createLogger)(`Redis`, this.config.pipelineConfig.azureAppName);
+    }
+    static getInstance(config) {
+        if (!this.instance) {
+            this.instance = new Redis(config);
+        }
+        if (!this.instance.client.isOpen) {
+            this.instance.initialize().then(() => this.instance.logger.info(`Initialized redis`)).catch((err) => this.instance.logger.info(`Error initializing Redis client: `, err));
+        }
+        return this.instance;
+    }
+    reinitialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logger.info("Redis: Reinitializing Redis...");
+                this.client = this.create_redis_client();
+                this.initialized = false;
+                yield this.initialize();
+            }
+            catch (err) {
+                this.logger.warn("Reinit failed:", { data: { error: err } });
+            }
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.client.isOpen) {
+                this.initialized = true;
+                return;
+            }
+            if (this.initializingPromise)
+                return this.initializingPromise;
+            this.initializingPromise = this._doInitialize().finally(() => {
+                this.initializingPromise = null;
+            });
+            return this.initializingPromise;
+        });
+    }
+    _doInitialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info(`Redis: Initializing redis....`);
+            try {
+                this.client.on('error', (err) => __awaiter(this, void 0, void 0, function* () { return yield this.handle_redis_error(err); }));
+                this.client.on('reconnecting', () => this.handle_redis_action("reconnecting"));
+                this.client.on('connect', () => this.handle_redis_action("connect"));
+                this.client.on('end', () => __awaiter(this, void 0, void 0, function* () { return yield this.handle_redis_action("end"); }));
+                this.client.on('ping', () => {
+                    console.log('Redis PING sent');
+                });
+                // Enable TCP keep-alive on the underlying socket after connecting
+                this.client.on('ready', () => {
+                    var _a, _b;
+                    this.logger;
+                    const socket = (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.socket;
+                    // Access the raw net.Socket and enable keep-alive
+                    const stream = this.client.socket;
+                    if (stream === null || stream === void 0 ? void 0 : stream.setKeepAlive) {
+                        stream.setKeepAlive(true, 10000);
+                        this.logger.info(``);
+                    }
+                });
+                // Enable keyspace notifications for expired events
+                try {
+                    yield this.client.connect();
+                    // Subscribe to events on local redis
+                    if (this.config.serverConfig.environment === "local") {
+                        yield this.client.configSet('notify-keyspace-events', 'Exg');
+                    }
+                    this.initialized = true;
+                    // // Create a dedicated subscriber connection for notifications
+                    this.subscriber = this.client.duplicate();
+                    // this.subscriber.on('error', async (err) => await this.handle_redis_error(err));
+                    yield this.subscriber.connect();
+                    this.initialized = true;
+                }
+                catch (e) {
+                    this.logger.warn('Redis: Redis init Error:', { data: { error: e } });
+                }
+                this.logger.info(`Redis: Initialized redis`);
+            }
+            catch (error) {
+                this.logger.error(`Redis: Error initializoing redis client`, { data: error });
+            }
+        });
+    }
+    // Subscribe to key expiry notifications
+    subscribeToExpiry(onExpire) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.subscriber)
+                throw new Error('Redis subscriber not initialized');
+            const db = (_b = (_a = this.client.options) === null || _a === void 0 ? void 0 : _a.database) !== null && _b !== void 0 ? _b : 0;
+            const pattern = `__keyevent@${db}__:expired`;
+            yield this.subscriber.pSubscribe(pattern, (expiredKey) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // Get the value before it expires (if possible) or use the key
+                    const pref = `${this.prefix}-`;
+                    const normalizedKey = expiredKey.startsWith(pref) ? expiredKey.slice(pref.length) : expiredKey;
+                    this.logger.info(`Redis: Expired key: ${normalizedKey} `);
+                    // Try to get the value from the expired key (might not work for expired keys)
+                    let value = null;
+                    try {
+                        value = yield this.get_object(expiredKey);
+                    }
+                    catch (e) {
+                        // Key already expired, use the key itself
+                    }
+                    onExpire(normalizedKey, value);
+                }
+                catch (e) {
+                    yield this.handle_redis_error(e);
+                }
+            }));
+        });
+    }
+    get_key(key, use_prefix = true) {
+        if (!use_prefix) {
+            return key;
+        }
+        else {
+            return `${this.prefix}-${key}`;
+        }
+    }
+    _get(final_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                yield this.initialize();
+            const value = yield this.withTimeout(() => this.client.get(final_key));
+            if (!value)
+                return null;
+            return value;
+        });
+    }
+    _set(final_key, _value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                yield this.initialize();
+            if (options) {
+                const expiry_timestamp = options.expires_at;
+                const ttl = options.ttl;
+                if (!expiry_timestamp)
+                    throw new Error("Expiry timestamp is required");
+                if (!ttl)
+                    throw new Error("TTL for key required");
+                let opt = {
+                    expiration: {
+                        type: "EXAT",
+                        value: expiry_timestamp
+                    },
+                };
+                let now_s = Math.floor(new Date().getTime() / 1000);
+                if (options.publish) {
+                    const publishName = options.publish.name;
+                    return yield this.withTimeout(() => {
+                        const multi = this.client.multi();
+                        multi.set(final_key, _value, ttl ? { EX: ttl } : undefined);
+                        multi.publish(publishName, _value);
+                        return multi.exec();
+                    });
+                }
+                else {
+                    return yield this.withTimeout(() => this.client.set(final_key, _value, { EX: ttl }));
+                }
+            }
+            else {
+                return yield this.withTimeout(() => this.client.set(final_key, _value));
+            }
+        });
+    }
+    _delete(final_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                yield this.initialize();
+            return yield this.withTimeout(() => this.client.del(final_key));
+        });
+    }
+    get(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            const value = yield this._get(key);
+            if (!value)
+                return null;
+            return value;
+        });
+    }
+    set(_key, _value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            return yield this._set(key, _value, options);
+        });
+    }
+    delete(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            return yield this._delete(key);
+        });
+    }
+    set_object(_key, _value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            return this._set(key, JSON.stringify(_value), options);
+        });
+    }
+    get_object(_key_1) {
+        return __awaiter(this, arguments, void 0, function* (_key, use_prefix = true) {
+            let key = this.get_key(_key, use_prefix);
+            this.logger.info(`Redis: Getting object with key: ${key} `);
+            const value = yield this._get(key);
+            return value ? JSON.parse(value) : null;
+        });
+    }
+    delete_object(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            return yield this._delete(key);
+        });
+    }
+    withTimeout(fn_1) {
+        return __awaiter(this, arguments, void 0, function* (fn, ms = 5000, retry = true) {
+            let timedOut = false;
+            try {
+                return yield Promise.race([
+                    fn(),
+                    new Promise((_, reject) => setTimeout(() => {
+                        timedOut = true;
+                        reject(new Error(`Redis command timed out after ${ms}ms`));
+                    }, ms)),
+                ]);
+            }
+            catch (err) {
+                if (timedOut && retry) {
+                    this.logger.warn(`Redis: command timed out, reinitializing and retrying once`);
+                    yield this.reinitialize();
+                    return this.withTimeout(fn, ms, false); // retry once on fresh connection, no further retry
+                }
+                throw err;
+            }
+        });
+    }
+    handle_redis_error(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info(`Redis: Redis Client Error: `, { data: { error } });
+            const error_data = { message: (error === null || error === void 0 ? void 0 : error.message) ? error.message : "Unexpected error occured" };
+            ElasticSearch_1.default.getInstance(this.config).index_log("Redis", this.handle_redis_error.name, "Error", "Redis Client Error", error_data);
+        });
+    }
+    handle_redis_action(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let message = "Redis Client Connected";
+            if (type === "reconnecting")
+                message = "Redis Client Reconnecting";
+            else if (type === "end") {
+                message = "Redis Client Connection Ended";
+                yield this.reinitialize();
+            }
+            this.logger.info(`Redis: Redis client action: ${message} type: ${type}`);
+        });
+    }
+}
+exports.default = Redis;

package/build/services/RedisListQueue.d.ts

@@ -0,0 +1,15 @@
+import { IConfig } from "../interfaces/config";
+declare class RedisListQueue {
+    private redis;
+    private readonly key;
+    private logger;
+    constructor(config: IConfig, name: string);
+    clear(): Promise<void>;
+    push<T>(message: T): Promise<void>;
+    pushMany<T>(messages: T[]): Promise<void>;
+    popBlocking<T>(timeoutSeconds?: number): Promise<T | null>;
+    popMany<T>(count: number, timeoutSeconds?: number): Promise<T[]>;
+    length(): Promise<number>;
+}
+export default RedisListQueue;
+//# sourceMappingURL=RedisListQueue.d.ts.map

package/build/services/RedisListQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisListQueue.d.ts","sourceRoot":"","sources":["../../src/services/RedisListQueue.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAG/C,cAAM,cAAc;IAChB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM;IAOnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;IAQlB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE;IAiBzB,WAAW,CAAC,CAAC,EAAE,cAAc,SAAI,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAWrD,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,SAAI,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAgB3D,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;CAGlC;AAED,eAAe,cAAc,CAAC"}

package/build/services/RedisListQueue.js

@@ -0,0 +1,81 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Redis_1 = __importDefault(require("./Redis"));
+const Logger_1 = require("../utils/Logger");
+class RedisListQueue {
+    constructor(config, name) {
+        this.redis = Redis_1.default.getInstance(config);
+        this.key = `${config.serverConfig.projectName}-${config.serverConfig.environment}:queue:${name}`;
+        this.logger = (0, Logger_1.createLogger)(`RedisListQueue`, config.pipelineConfig.azureAppName);
+    }
+    // Clear the queue completely
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.client.del(this.key);
+        });
+    }
+    // Push single message 
+    push(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.client.rPush(this.key, JSON.stringify(message));
+        });
+    }
+    // Push many messages
+    pushMany(messages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!messages.length)
+                return;
+            const multi = this.redis.client.multi();
+            for (const m of messages) {
+                multi.rPush(this.key, JSON.stringify(m));
+            }
+            yield multi.exec();
+            const len = yield this.redis.client.lLen(this.key);
+            this.logger.info(`Updated Event Replay Queue ${this.key} length: ${len}`);
+        });
+    }
+    // Blocking pop (consumer side)
+    popBlocking() {
+        return __awaiter(this, arguments, void 0, function* (timeoutSeconds = 0) {
+            const result = yield this.redis.client.blPop(this.key, timeoutSeconds);
+            if (!result)
+                return null;
+            return JSON.parse(result.element);
+        });
+    }
+    // Blocking pop many
+    popMany(count_1) {
+        return __awaiter(this, arguments, void 0, function* (count, timeoutSeconds = 0) {
+            const results = [];
+            const first = yield this.redis.client.blPop(this.key, timeoutSeconds);
+            if (!first)
+                return results;
+            results.push(JSON.parse(first.element));
+            for (let i = 1; i < count; i++) {
+                const raw = yield this.redis.client.lPop(this.key);
+                if (!raw)
+                    break;
+                results.push(JSON.parse(raw));
+            }
+            return results;
+        });
+    }
+    length() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.redis.client.lLen(this.key);
+        });
+    }
+}
+exports.default = RedisListQueue;

package/build/services/RedisPubSub.d.ts

@@ -0,0 +1,41 @@
+import { RedisClientType } from "@redis/client";
+import { IConfig } from "../interfaces/config";
+import { RedisPatternEventNames, RedisPublishNames } from "./types/RedisPubSub";
+interface SetOptions {
+    expires_at?: number;
+    ttl: number;
+}
+declare class RedisPubSub {
+    private config;
+    client: RedisClientType;
+    prefix: string;
+    subscriber?: RedisClientType;
+    initialized: boolean;
+    private logger;
+    constructor(config: IConfig, prefix: string);
+    private create_redis_client;
+    private reinitialize;
+    initialize(): Promise<void>;
+    psubscribe(events: {
+        onEvent: (key: string, eventName: RedisPatternEventNames, value?: any) => void;
+        eventName: RedisPatternEventNames;
+    }[]): Promise<void>;
+    subscribe(events: {
+        onEvent: (data: any) => void;
+        eventName: RedisPublishNames;
+    }[]): Promise<void>;
+    get_key(key: string, _prefix?: string): string;
+    private _get;
+    private _set;
+    private _delete;
+    get(_key: string): Promise<string | null>;
+    set(_key: string, _value: string, options?: SetOptions): Promise<string | null>;
+    delete(_key: string): Promise<number>;
+    set_object(_key: string, _value: any, options?: SetOptions): Promise<string | null>;
+    get_object(_key: string): Promise<any>;
+    delete_object(_key: string): Promise<number>;
+    private handle_redis_error;
+    private handle_redis_action;
+}
+export default RedisPubSub;
+//# sourceMappingURL=RedisPubSub.d.ts.map

package/build/services/RedisPubSub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisPubSub.d.ts","sourceRoot":"","sources":["../../src/services/RedisPubSub.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAIhF,UAAU,UAAU;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;CACf;AAID,cAAM,WAAW;IACb,OAAO,CAAC,MAAM,CAAU;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,OAAO,CAAC;IAC5B,OAAO,CAAC,MAAM,CAAS;gBACX,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM;IAU3C,OAAO,CAAC,mBAAmB,CAyB1B;YAEa,YAAY;IAWb,UAAU;IAoCV,UAAU,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,sBAAsB,EAAE,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;QAAC,SAAS,EAAE,sBAAsB,CAAA;KAAE,EAAE;IAsB1I,SAAS,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;QAAC,SAAS,EAAE,iBAAiB,CAAA;KAAE,EAAE;IAqBxF,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;YAI9B,IAAI;YAOJ,IAAI;YA2BJ,OAAO;IAMR,GAAG,CAAC,IAAI,EAAE,MAAM;IAQhB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU;IAKtD,MAAM,CAAC,IAAI,EAAE,MAAM;IAKnB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,UAAU;IAK1D,UAAU,CAAC,IAAI,EAAE,MAAM;IAMvB,aAAa,CAAC,IAAI,EAAE,MAAM;YAMzB,kBAAkB;YAMlB,mBAAmB;CASpC;AAED,eAAe,WAAW,CAAC"}