@diia-inhouse/redis 2.30.21 → 3.1.1

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { RedisConfig, RedisMode, RedisOptions, RedisStatus, RedisStatusValue, StoreStatus } from "./interfaces/redis.js";
+import { MessageHandler, PubSubServiceProvider, PubSubStatus, PubSubStatusResult } from "./interfaces/pubsub.js";
+import { Lock, LockOptions, MutexStatusResult, RedlockMutex } from "./interfaces/mutex.js";
+import { SetValueOptions, StoreStatusResult, TaggedStoreValue, TagsConfig, ThrottleResult } from "./interfaces/store.js";
+import { PubSubService } from "./services/pubsub.js";
+import { RedisService } from "./services/redis.js";
+import { StoreService } from "./services/store.js";
+import { RedlockService } from "./services/mutex.js";
+import { RedisDeps } from "./interfaces/deps.js";
+export { Lock, LockOptions, MessageHandler, MutexStatusResult, PubSubService, PubSubServiceProvider, PubSubStatus, PubSubStatusResult, RedisConfig, RedisDeps, RedisMode, RedisOptions, RedisService, RedisStatus, RedisStatusValue, RedlockMutex, RedlockService, SetValueOptions, StoreService, StoreStatus, StoreStatusResult, TaggedStoreValue, TagsConfig, ThrottleResult };

package/dist/index.js

@@ -1,20 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./interfaces"), exports);
-__exportStar(require("./interfaces/deps"), exports);
-__exportStar(require("./services"), exports);
-//# sourceMappingURL=index.js.map
+import { RedisMode, RedisStatusValue } from "./interfaces/redis.js";
+import { RedlockMutex } from "./interfaces/mutex.js";
+import "./interfaces/index.js";
+import { RedisService } from "./services/redis.js";
+import { PubSubService } from "./services/pubsub.js";
+import { StoreService } from "./services/store.js";
+import { RedlockService } from "./services/mutex.js";
+import "./services/index.js";
+export { PubSubService, RedisMode, RedisService, RedisStatusValue, RedlockMutex, RedlockService, StoreService };

package/dist/interfaces/deps.d.ts

@@ -0,0 +1,11 @@
+import { PubSubService } from "../services/pubsub.js";
+import { StoreService } from "../services/store.js";
+import { RedlockService } from "../services/mutex.js";
+//#region src/interfaces/deps.d.ts
+type RedisDeps = {
+  pubsub?: PubSubService;
+  redlock?: RedlockService;
+  store?: StoreService;
+};
+//#endregion
+export { RedisDeps };

package/dist/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+import { RedisConfig, RedisMode, RedisOptions, RedisStatus, RedisStatusValue, StoreStatus } from "./redis.js";
+import { MessageHandler, PubSubServiceProvider, PubSubStatus, PubSubStatusResult } from "./pubsub.js";
+import { Lock, LockOptions, MutexStatusResult, RedlockMutex } from "./mutex.js";
+import { SetValueOptions, StoreStatusResult, TaggedStoreValue, TagsConfig, ThrottleResult } from "./store.js";

package/dist/interfaces/index.js

@@ -1,21 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./pubsub"), exports);
-__exportStar(require("./redis"), exports);
-__exportStar(require("./mutex"), exports);
-__exportStar(require("./store"), exports);
-//# sourceMappingURL=index.js.map
+import "./redis.js";
+import "./mutex.js";
+export {};

package/dist/interfaces/mutex.d.ts

@@ -0,0 +1,16 @@
+import { RedlockMutex, RedlockMutex as RedlockMutex$1 } from "redis-semaphore";
+
+//#region src/interfaces/mutex.d.ts
+type Lock = RedlockMutex;
+type MutexStatusResult = {
+  mutex: string;
+};
+type LockOptions = {
+  /**
+  * Time in milliseconds between acquire attempts if resource locked
+  * @defaultValue 500
+  */
+  retryInterval?: number;
+};
+//#endregion
+export { Lock, LockOptions, MutexStatusResult, RedlockMutex$1 as RedlockMutex };

package/dist/interfaces/mutex.js

@@ -1,6 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedlockMutex = void 0;
-var redis_semaphore_1 = require("redis-semaphore");
-Object.defineProperty(exports, "RedlockMutex", { enumerable: true, get: function () { return redis_semaphore_1.RedlockMutex; } });
-//# sourceMappingURL=mutex.js.map
+import { RedlockMutex as RedlockMutex$1 } from "redis-semaphore";
+export { RedlockMutex$1 as RedlockMutex };

package/dist/interfaces/pubsub.d.ts

@@ -0,0 +1,19 @@
+import { RedisStatus } from "./redis.js";
+
+//#region src/interfaces/pubsub.d.ts
+interface PubSubStatus {
+  pub: RedisStatus;
+  sub: RedisStatus;
+}
+type PubSubStatusResult = {
+  pubsub: PubSubStatus;
+};
+type MessageHandler = (message: string) => Promise<unknown>;
+interface PubSubServiceProvider {
+  unsubscribe(channel: string): Promise<unknown>;
+  publish(channel: string, data: unknown): Promise<number>;
+  onceChannelMessage(channel: string, handler: MessageHandler): Promise<void>;
+  getStatus(): PubSubStatus;
+}
+//#endregion
+export { MessageHandler, PubSubServiceProvider, PubSubStatus, PubSubStatusResult };

package/dist/interfaces/redis.d.ts

@@ -0,0 +1,28 @@
+import { RedisOptions } from "ioredis";
+
+//#region src/interfaces/redis.d.ts
+declare enum RedisMode {
+  ReadWrite = "READ-WRITE",
+  ReadOnly = "READ-ONLY"
+}
+interface RedisOptions$1 extends RedisOptions {
+  maxRetryAttempts?: number;
+  initialRetryDelay?: number;
+  maxRetryDelay?: number;
+  redisMode?: RedisMode;
+}
+declare enum RedisStatusValue {
+  Ready = "ready"
+}
+type RedisStatus = RedisStatusValue | string;
+interface RedisConfig {
+  readWrite: RedisOptions$1;
+  readOnly: RedisOptions$1;
+  enablePubsub?: boolean;
+}
+interface StoreStatus {
+  readWrite: RedisStatus;
+  readOnly: RedisStatus;
+}
+//#endregion
+export { RedisConfig, RedisMode, RedisOptions$1 as RedisOptions, RedisStatus, RedisStatusValue, StoreStatus };

package/dist/interfaces/redis.js

@@ -1,13 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisStatusValue = exports.RedisMode = void 0;
-var RedisMode;
-(function (RedisMode) {
-    RedisMode["ReadWrite"] = "READ-WRITE";
-    RedisMode["ReadOnly"] = "READ-ONLY";
-})(RedisMode || (exports.RedisMode = RedisMode = {}));
-var RedisStatusValue;
-(function (RedisStatusValue) {
-    RedisStatusValue["Ready"] = "ready";
-})(RedisStatusValue || (exports.RedisStatusValue = RedisStatusValue = {}));
-//# sourceMappingURL=redis.js.map
+//#region src/interfaces/redis.ts
+let RedisMode = /* @__PURE__ */ function(RedisMode) {
+	RedisMode["ReadWrite"] = "READ-WRITE";
+	RedisMode["ReadOnly"] = "READ-ONLY";
+	return RedisMode;
+}({});
+let RedisStatusValue = /* @__PURE__ */ function(RedisStatusValue) {
+	RedisStatusValue["Ready"] = "ready";
+	return RedisStatusValue;
+}({});
+//#endregion
+export { RedisMode, RedisStatusValue };

package/dist/interfaces/store.d.ts

@@ -0,0 +1,32 @@
+import { StoreStatus } from "./redis.js";
+
+//#region src/interfaces/store.d.ts
+type TagsConfig = { [tag in string]?: number };
+interface TaggedStoreValue {
+  data: string;
+  timestamp: number;
+  tags: string[];
+}
+interface SetValueOptions {
+  /**
+  * Time to live in milliseconds.
+  * If not set, the key will be permanent.
+  */
+  ttl?: number;
+  /**
+  * Tags associated with the value.
+  */
+  tags?: string[];
+}
+interface ThrottleResult {
+  limited: boolean;
+  totalLimit: number;
+  remaining: number;
+  retryAfterSec: number;
+  resetAfterSec: number;
+}
+type StoreStatusResult = {
+  store: StoreStatus;
+};
+//#endregion
+export { SetValueOptions, StoreStatusResult, TaggedStoreValue, TagsConfig, ThrottleResult };

package/dist/services/index.d.ts

@@ -0,0 +1,4 @@
+import { PubSubService } from "./pubsub.js";
+import { RedisService } from "./redis.js";
+import { StoreService } from "./store.js";
+import { RedlockService } from "./mutex.js";

package/dist/services/index.js

@@ -1,21 +1,5 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./pubsub"), exports);
-__exportStar(require("./redis"), exports);
-__exportStar(require("./store"), exports);
-__exportStar(require("./mutex"), exports);
-//# sourceMappingURL=index.js.map
+import "./redis.js";
+import "./pubsub.js";
+import "./store.js";
+import "./mutex.js";
+export {};

package/dist/services/mutex.d.ts

@@ -0,0 +1,19 @@
+import { RedisConfig } from "../interfaces/redis.js";
+import { LockOptions, MutexStatusResult } from "../interfaces/mutex.js";
+import { RedlockMutex } from "redis-semaphore";
+import { HealthCheckResult, Logger, OnDestroy, OnHealthCheck } from "@diia-inhouse/types";
+
+//#region src/services/mutex.d.ts
+declare class RedlockService implements OnHealthCheck, OnDestroy {
+  private readonly storeConfig;
+  private readonly logger;
+  private clientRW;
+  constructor(storeConfig: RedisConfig, logger: Logger);
+  onHealthCheck(): Promise<HealthCheckResult<MutexStatusResult>>;
+  onDestroy(): Promise<void>;
+  lock(resource: string, ttl?: number, {
+    retryInterval
+  }?: LockOptions): Promise<RedlockMutex>;
+}
+//#endregion
+export { RedlockService };

package/dist/services/mutex.js

@@ -1,44 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedlockService = void 0;
-const redis_semaphore_1 = require("redis-semaphore");
-const types_1 = require("@diia-inhouse/types");
-const redis_1 = require("../interfaces/redis");
-const redis_2 = require("./redis");
-class RedlockService {
-    storeConfig;
-    logger;
-    clientRW;
-    constructor(storeConfig, logger) {
-        this.storeConfig = storeConfig;
-        this.logger = logger;
-        const { readWrite } = this.storeConfig;
-        this.clientRW = redis_2.RedisService.createClient({ ...readWrite, redisMode: redis_1.RedisMode.ReadWrite }, this.logger);
-        this.clientRW.on('connect', () => {
-            const { host, port, sentinels } = readWrite;
-            this.logger.info('Redis REDLOCK READ-WRITE connection open', { host, port, sentinels });
-        });
-        this.clientRW.on('error', (err) => {
-            this.logger.error('Redis REDLOCK READ-WRITE connection error ', { err });
-        });
-    }
-    async onHealthCheck() {
-        const cacheStatus = this.clientRW.status;
-        const status = cacheStatus === redis_1.RedisStatusValue.Ready ? types_1.HttpStatusCode.OK : types_1.HttpStatusCode.SERVICE_UNAVAILABLE;
-        return {
-            status,
-            details: { mutex: cacheStatus },
-        };
-    }
-    async onDestroy() {
-        await this.clientRW.quit();
-    }
-    async lock(resource, ttl = 60000, { retryInterval = 500 } = {}) {
-        this.logger.info(`Start LOCK resource [${resource}] for ttl [${ttl}]ms`);
-        const mutex = new redis_semaphore_1.RedlockMutex([this.clientRW], resource, { lockTimeout: ttl, acquireTimeout: ttl * 2, retryInterval });
-        await mutex.acquire();
-        return mutex;
-    }
-}
-exports.RedlockService = RedlockService;
-//# sourceMappingURL=mutex.js.map
+import "../interfaces/redis.js";
+import { RedisService } from "./redis.js";
+import { RedlockMutex } from "redis-semaphore";
+import { HttpStatusCode } from "@diia-inhouse/types";
+//#region src/services/mutex.ts
+var RedlockService = class {
+	storeConfig;
+	logger;
+	clientRW;
+	constructor(storeConfig, logger) {
+		this.storeConfig = storeConfig;
+		this.logger = logger;
+		const { readWrite } = this.storeConfig;
+		this.clientRW = RedisService.createClient({
+			...readWrite,
+			redisMode: "READ-WRITE"
+		}, this.logger);
+		this.clientRW.on("connect", () => {
+			const { host, port, sentinels } = readWrite;
+			this.logger.info("Redis REDLOCK READ-WRITE connection open", {
+				host,
+				port,
+				sentinels
+			});
+		});
+		this.clientRW.on("error", (err) => {
+			this.logger.error("Redis REDLOCK READ-WRITE connection error ", { err });
+		});
+	}
+	async onHealthCheck() {
+		const cacheStatus = this.clientRW.status;
+		return {
+			status: cacheStatus === "ready" ? HttpStatusCode.OK : HttpStatusCode.SERVICE_UNAVAILABLE,
+			details: { mutex: cacheStatus }
+		};
+	}
+	async onDestroy() {
+		await this.clientRW.quit();
+	}
+	async lock(resource, ttl = 6e4, { retryInterval = 500 } = {}) {
+		this.logger.info(`Start LOCK resource [${resource}] for ttl [${ttl}]ms`);
+		const mutex = new RedlockMutex([this.clientRW], resource, {
+			lockTimeout: ttl,
+			acquireTimeout: ttl * 2,
+			retryInterval
+		});
+		await mutex.acquire();
+		return mutex;
+	}
+};
+//#endregion
+export { RedlockService };

package/dist/services/providers/pubsub.js

@@ -1,89 +1,96 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PubSubProvider = void 0;
-const redis_1 = require("../../interfaces/redis");
-const redis_2 = require("../redis");
-class PubSubProvider {
-    logger;
-    pub;
-    sub;
-    oneTimeHandlerByChannel = {};
-    handlerByChannel = {};
-    constructor({ readWrite }, logger) {
-        this.logger = logger;
-        this.pub = redis_2.RedisService.createClient({ ...readWrite, redisMode: redis_1.RedisMode.ReadWrite }, this.logger);
-        this.sub = redis_2.RedisService.createClient({ ...readWrite, redisMode: redis_1.RedisMode.ReadWrite, autoResubscribe: true }, this.logger);
-        this.pub.on('connect', () => {
-            const { host, port, sentinels } = readWrite;
-            this.logger.info('Redis READ-WRITE pub connection open', { host, port, sentinels });
-        });
-        this.pub.on('error', (err) => {
-            this.logger.error('Redis READ-WRITE pub connection error ', { err });
-        });
-        this.sub.on('connect', () => {
-            const { host, port, sentinels } = readWrite;
-            this.logger.info('Redis READ-WRITE sub connection open', { host, port, sentinels });
-        });
-        this.sub.on('error', (err) => {
-            this.logger.error('Redis READ-WRITE sub connection error ', { err });
-        });
-        this.sub.on('message', async (channel, message) => {
-            const oneTimeHandler = this.oneTimeHandlerByChannel[channel];
-            if (oneTimeHandler) {
-                delete this.oneTimeHandlerByChannel[channel];
-                await this.sub.unsubscribe(channel);
-                try {
-                    await oneTimeHandler(message);
-                }
-                catch (err) {
-                    this.logger.error(`Failed to handle message from the channel ${channel}`, { err });
-                }
-                return;
-            }
-            const handlerByChannel = this.handlerByChannel[channel];
-            if (handlerByChannel) {
-                try {
-                    await handlerByChannel(message);
-                }
-                catch (err) {
-                    this.logger.error(`Failed to handle message from the channel ${channel}`, { err });
-                }
-                return;
-            }
-            this.logger.error(`Could not find a message handler for the channel ${channel}`);
-        });
-    }
-    async unsubscribe(channel) {
-        delete this.oneTimeHandlerByChannel[channel];
-        delete this.handlerByChannel[channel];
-        return await this.sub.unsubscribe(channel);
-    }
-    async publish(channel, data) {
-        return await this.pub.publish(channel, JSON.stringify(data));
-    }
-    async onChannelMessage(channel, handler) {
-        if (Object.keys(this.handlerByChannel).includes(channel)) {
-            throw new Error(`Handler already exists by the provided channel ${channel}`);
-        }
-        this.handlerByChannel[channel] = handler;
-        await this.sub.subscribe(channel);
-    }
-    async onceChannelMessage(channel, handler) {
-        if (Object.keys(this.oneTimeHandlerByChannel).includes(channel)) {
-            throw new Error(`Handler already exists by the provided channel ${channel}`);
-        }
-        this.oneTimeHandlerByChannel[channel] = handler;
-        await this.sub.subscribe(channel);
-    }
-    async quit() {
-        await Promise.all([this.pub.quit(), this.sub.quit()]);
-    }
-    getStatus() {
-        return {
-            pub: this.pub.status,
-            sub: this.sub.status,
-        };
-    }
-}
-exports.PubSubProvider = PubSubProvider;
-//# sourceMappingURL=pubsub.js.map
+import "../../interfaces/redis.js";
+import { RedisService } from "../redis.js";
+//#region src/services/providers/pubsub.ts
+var PubSubProvider = class {
+	logger;
+	pub;
+	sub;
+	oneTimeHandlerByChannel = {};
+	handlerByChannel = {};
+	constructor({ readWrite }, logger) {
+		this.logger = logger;
+		this.pub = RedisService.createClient({
+			...readWrite,
+			redisMode: "READ-WRITE"
+		}, this.logger);
+		this.sub = RedisService.createClient({
+			...readWrite,
+			redisMode: "READ-WRITE",
+			autoResubscribe: true
+		}, this.logger);
+		this.pub.on("connect", () => {
+			const { host, port, sentinels } = readWrite;
+			this.logger.info("Redis READ-WRITE pub connection open", {
+				host,
+				port,
+				sentinels
+			});
+		});
+		this.pub.on("error", (err) => {
+			this.logger.error("Redis READ-WRITE pub connection error ", { err });
+		});
+		this.sub.on("connect", () => {
+			const { host, port, sentinels } = readWrite;
+			this.logger.info("Redis READ-WRITE sub connection open", {
+				host,
+				port,
+				sentinels
+			});
+		});
+		this.sub.on("error", (err) => {
+			this.logger.error("Redis READ-WRITE sub connection error ", { err });
+		});
+		this.sub.on("message", async (channel, message) => {
+			const oneTimeHandler = this.oneTimeHandlerByChannel[channel];
+			if (oneTimeHandler) {
+				delete this.oneTimeHandlerByChannel[channel];
+				await this.sub.unsubscribe(channel);
+				try {
+					await oneTimeHandler(message);
+				} catch (err) {
+					this.logger.error(`Failed to handle message from the channel ${channel}`, { err });
+				}
+				return;
+			}
+			const handlerByChannel = this.handlerByChannel[channel];
+			if (handlerByChannel) {
+				try {
+					await handlerByChannel(message);
+				} catch (err) {
+					this.logger.error(`Failed to handle message from the channel ${channel}`, { err });
+				}
+				return;
+			}
+			this.logger.error(`Could not find a message handler for the channel ${channel}`);
+		});
+	}
+	async unsubscribe(channel) {
+		delete this.oneTimeHandlerByChannel[channel];
+		delete this.handlerByChannel[channel];
+		return await this.sub.unsubscribe(channel);
+	}
+	async publish(channel, data) {
+		return await this.pub.publish(channel, JSON.stringify(data));
+	}
+	async onChannelMessage(channel, handler) {
+		if (Object.keys(this.handlerByChannel).includes(channel)) throw new Error(`Handler already exists by the provided channel ${channel}`);
+		this.handlerByChannel[channel] = handler;
+		await this.sub.subscribe(channel);
+	}
+	async onceChannelMessage(channel, handler) {
+		if (Object.keys(this.oneTimeHandlerByChannel).includes(channel)) throw new Error(`Handler already exists by the provided channel ${channel}`);
+		this.oneTimeHandlerByChannel[channel] = handler;
+		await this.sub.subscribe(channel);
+	}
+	async quit() {
+		await Promise.all([this.pub.quit(), this.sub.quit()]);
+	}
+	getStatus() {
+		return {
+			pub: this.pub.status,
+			sub: this.sub.status
+		};
+	}
+};
+//#endregion
+export { PubSubProvider };

package/dist/services/pubsub.d.ts

@@ -0,0 +1,19 @@
+import { RedisConfig } from "../interfaces/redis.js";
+import { MessageHandler, PubSubStatusResult } from "../interfaces/pubsub.js";
+import { HealthCheckResult, Logger, OnDestroy, OnHealthCheck } from "@diia-inhouse/types";
+
+//#region src/services/pubsub.d.ts
+declare class PubSubService implements OnHealthCheck, OnDestroy {
+  private readonly redisConfig;
+  private readonly logger;
+  private readonly provider;
+  constructor(redisConfig: RedisConfig, logger: Logger);
+  onHealthCheck(): Promise<HealthCheckResult<PubSubStatusResult>>;
+  onDestroy(): Promise<void>;
+  unsubscribe(channel: string): Promise<unknown>;
+  publish(channel: string, data: unknown): Promise<number>;
+  onceChannelMessage(channel: string, handler: MessageHandler): Promise<void>;
+  onChannelMessage(channel: string, handler: MessageHandler): Promise<void>;
+}
+//#endregion
+export { PubSubService };