@diia-inhouse/redis 2.30.21 → 3.1.0

package/dist/services/pubsub.js

@@ -1,43 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PubSubService = void 0;
-const types_1 = require("@diia-inhouse/types");
-const redis_1 = require("../interfaces/redis");
-const pubsub_1 = require("./providers/pubsub");
-class PubSubService {
-    redisConfig;
-    logger;
-    provider;
-    constructor(redisConfig, logger) {
-        this.redisConfig = redisConfig;
-        this.logger = logger;
-        this.provider = new pubsub_1.PubSubProvider(this.redisConfig, this.logger);
-    }
-    async onHealthCheck() {
-        const pubSubStatus = this.provider.getStatus();
-        const status = Object.values(pubSubStatus).some((s) => s !== redis_1.RedisStatusValue.Ready)
-            ? types_1.HttpStatusCode.SERVICE_UNAVAILABLE
-            : types_1.HttpStatusCode.OK;
-        return {
-            status,
-            details: { pubsub: pubSubStatus },
-        };
-    }
-    async onDestroy() {
-        await this.provider.quit();
-    }
-    async unsubscribe(channel) {
-        return await this.provider.unsubscribe(channel);
-    }
-    async publish(channel, data) {
-        return await this.provider.publish(channel, data);
-    }
-    onceChannelMessage(channel, handler) {
-        return this.provider.onceChannelMessage(channel, handler);
-    }
-    async onChannelMessage(channel, handler) {
-        return await this.provider.onChannelMessage(channel, handler);
-    }
-}
-exports.PubSubService = PubSubService;
-//# sourceMappingURL=pubsub.js.map
+import "../interfaces/redis.js";
+import { PubSubProvider } from "./providers/pubsub.js";
+import { HttpStatusCode } from "@diia-inhouse/types";
+//#region src/services/pubsub.ts
+var PubSubService = class {
+	redisConfig;
+	logger;
+	provider;
+	constructor(redisConfig, logger) {
+		this.redisConfig = redisConfig;
+		this.logger = logger;
+		this.provider = new PubSubProvider(this.redisConfig, this.logger);
+	}
+	async onHealthCheck() {
+		const pubSubStatus = this.provider.getStatus();
+		return {
+			status: Object.values(pubSubStatus).some((s) => s !== "ready") ? HttpStatusCode.SERVICE_UNAVAILABLE : HttpStatusCode.OK,
+			details: { pubsub: pubSubStatus }
+		};
+	}
+	async onDestroy() {
+		await this.provider.quit();
+	}
+	async unsubscribe(channel) {
+		return await this.provider.unsubscribe(channel);
+	}
+	async publish(channel, data) {
+		return await this.provider.publish(channel, data);
+	}
+	onceChannelMessage(channel, handler) {
+		return this.provider.onceChannelMessage(channel, handler);
+	}
+	async onChannelMessage(channel, handler) {
+		return await this.provider.onChannelMessage(channel, handler);
+	}
+};
+//#endregion
+export { PubSubService };

package/dist/services/redis.d.ts

@@ -0,0 +1,10 @@
+import { RedisOptions as RedisOptions$1 } from "../interfaces/redis.js";
+import { Logger } from "@diia-inhouse/types";
+import { Redis } from "ioredis";
+
+//#region src/services/redis.d.ts
+declare const RedisService: {
+  createClient(extendedRedisOptions: RedisOptions$1, logger: Logger): Redis;
+};
+//#endregion
+export { RedisService };

package/dist/services/redis.js

@@ -1,65 +1,84 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisService = void 0;
-const ioredis_1 = __importDefault(require("ioredis"));
-const types_1 = require("@diia-inhouse/types");
-exports.RedisService = {
-    createClient(extendedRedisOptions, logger) {
-        const { maxRetryAttempts = 10, initialRetryDelay = types_1.DurationMs.Second, maxRetryDelay = types_1.DurationMs.Second * 10, ...options } = extendedRedisOptions;
-        const { host, port, redisMode } = options;
-        const redisOptions = {
-            keepAlive: types_1.DurationMs.Second * 10,
-            enableAutoPipelining: true,
-            reconnectOnError: (err) => {
-                logger.error('Redis error detected due:', { err, host, port, redisMode });
-                const targetError = 'READONLY';
-                if (err.message.includes(targetError)) {
-                    // Force reconnect and resend the failed command after reconnection
-                    // https://github.com/redis/ioredis?tab=readme-ov-file#reconnect-on-error
-                    logger.warn('Redis encountered READONLY error, forcing reconnect', { host, port, redisMode });
-                    return 2;
-                }
-                return false;
-            },
-            retryStrategy: (attempts) => {
-                if (attempts > maxRetryAttempts) {
-                    logger.error(`Redis connection failed after ${maxRetryAttempts} attempts. Shutting down connection attempts.`, {
-                        host,
-                        port,
-                        redisMode,
-                    });
-                    return null; // Stop retrying (null instead of false)
-                }
-                const delay = Math.min(initialRetryDelay * Math.pow(2, attempts - 1), maxRetryDelay);
-                logger.debug(`Redis connection attempt ${attempts} failed. Retrying in ${delay}ms...`, {
-                    host,
-                    port,
-                    redisMode,
-                });
-                return delay;
-            },
-            ...options,
-        };
-        const client = new ioredis_1.default(redisOptions);
-        client.on('ready', () => {
-            logger.debug('Redis client is ready to accept commands', { host, port, redisMode });
-        });
-        client.on('close', () => {
-            logger.debug('Redis connection closed', { host, port, redisMode });
-        });
-        client.on('reconnecting', (timeToReconnect) => {
-            logger.debug(`Redis client is reconnecting in ${timeToReconnect}ms`, { host, port, redisMode });
-        });
-        client.on('end', () => {
-            logger.debug('Redis connection ended, no more reconnection attempts will be made', { host, port, redisMode });
-        });
-        client.on('wait', () => {
-            logger.debug('Redis client is waiting to reconnect', { host, port, redisMode });
-        });
-        return client;
-    },
-};
-//# sourceMappingURL=redis.js.map
+import { DurationMs } from "@diia-inhouse/types";
+import { Redis } from "ioredis";
+//#region src/services/redis.ts
+const RedisService = { createClient(extendedRedisOptions, logger) {
+	const { maxRetryAttempts = 10, initialRetryDelay = DurationMs.Second, maxRetryDelay = DurationMs.Second * 10, ...options } = extendedRedisOptions;
+	const { host, port, redisMode } = options;
+	const client = new Redis({
+		keepAlive: DurationMs.Second * 10,
+		enableAutoPipelining: true,
+		reconnectOnError: (err) => {
+			logger.error("Redis error detected due:", {
+				err,
+				host,
+				port,
+				redisMode
+			});
+			if (err.message.includes("READONLY")) {
+				logger.warn("Redis encountered READONLY error, forcing reconnect", {
+					host,
+					port,
+					redisMode
+				});
+				return 2;
+			}
+			return false;
+		},
+		retryStrategy: (attempts) => {
+			if (attempts > maxRetryAttempts) {
+				logger.error(`Redis connection failed after ${maxRetryAttempts} attempts. Shutting down connection attempts.`, {
+					host,
+					port,
+					redisMode
+				});
+				return null;
+			}
+			const delay = Math.min(initialRetryDelay * Math.pow(2, attempts - 1), maxRetryDelay);
+			logger.debug(`Redis connection attempt ${attempts} failed. Retrying in ${delay}ms...`, {
+				host,
+				port,
+				redisMode
+			});
+			return delay;
+		},
+		...options
+	});
+	client.on("ready", () => {
+		logger.debug("Redis client is ready to accept commands", {
+			host,
+			port,
+			redisMode
+		});
+	});
+	client.on("close", () => {
+		logger.debug("Redis connection closed", {
+			host,
+			port,
+			redisMode
+		});
+	});
+	client.on("reconnecting", (timeToReconnect) => {
+		logger.debug(`Redis client is reconnecting in ${timeToReconnect}ms`, {
+			host,
+			port,
+			redisMode
+		});
+	});
+	client.on("end", () => {
+		logger.debug("Redis connection ended, no more reconnection attempts will be made", {
+			host,
+			port,
+			redisMode
+		});
+	});
+	client.on("wait", () => {
+		logger.debug("Redis client is waiting to reconnect", {
+			host,
+			port,
+			redisMode
+		});
+	});
+	return client;
+} };
+//#endregion
+export { RedisService };

package/dist/services/store.d.ts

@@ -0,0 +1,47 @@
+import { RedisConfig } from "../interfaces/redis.js";
+import { SetValueOptions, StoreStatusResult, ThrottleResult } from "../interfaces/store.js";
+import { HealthCheckResult, Logger, OnDestroy, OnHealthCheck } from "@diia-inhouse/types";
+
+//#region src/services/store.d.ts
+declare class StoreService implements OnHealthCheck, OnDestroy {
+  private readonly storeConfig;
+  private readonly logger;
+  private clientRW;
+  private clientRO;
+  private tagsKey;
+  constructor(storeConfig: RedisConfig, logger: Logger);
+  onHealthCheck(): Promise<HealthCheckResult<StoreStatusResult>>;
+  onDestroy(): Promise<void>;
+  get(key: string): Promise<string | null>;
+  mget(...keys: string[]): Promise<(string | null)[]>;
+  hget(key: string, field: string): Promise<string | null>;
+  hlen(key: string): Promise<number | null>;
+  hgetall(key: string): Promise<Record<string, string> | null>;
+  hvals(key: string): Promise<string[]>;
+  hscan(key: string, cursor: number | string, count: number): Promise<{
+    cursor: string;
+    elements: string[];
+  }>;
+  scan(matchPattern: string, cursor: number | string, count: number): Promise<{
+    cursor: string;
+    elements: string[];
+  }>;
+  lrange(key: string, start: number, stop: number): Promise<string[] | null>;
+  getUsingTags(key: string): Promise<string | null>;
+  set(key: string, value: string, options?: SetValueOptions): Promise<"OK" | null>;
+  hset(key: string, value: Record<string, string>): Promise<number>;
+  lpush(key: string, ...values: string[]): Promise<number>;
+  incrby(key: string, value: number): Promise<number>;
+  keys(pattern: string): Promise<string[]>;
+  remember(key: string, closure: () => Promise<string | null>, options?: SetValueOptions): Promise<string | null>;
+  remove(...keys: string[]): Promise<number>;
+  hdel(key: string, ...fields: string[]): Promise<number>;
+  expire(key: string, seconds: number): Promise<number>;
+  bumpTags(tags: string[]): Promise<"OK" | null>;
+  throttle(key: string, maxBurst: number, rate: number, periodSec: number, quantity?: number): Promise<ThrottleResult>;
+  flushDb(): Promise<"OK">;
+  private validate;
+  private wrapValueWithMetadata;
+}
+//#endregion
+export { StoreService };